LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: texpr
Tree texpr(f, tok) int tok; dclproto(Tree (*f),(int)); {
	int n = ntree;
	Tree p;

	ntree = sizeof trees/sizeof trees[0];
	p = (*f)(tok);
	ntree = n;
	return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movl 0x183d0(%rip), %ebx     # 0x2ed78
movl $0x64, 0x183c6(%rip)    # 0x2ed78
movl %esi, %edi
callq *%rax
movl %ebx, 0x183bc(%rip)     # 0x2ed78
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: nodeid
int nodeid(p) Tree p; {
	int i = 1;

	ids[nid].node = p;
	while (ids[i].node != p)
		i++;
	if (i == nid)
		ids[nid++].printed = 0;
	return i;
}

// Assembly:
movslq 0x12d8a(%rip), %rcx     # 0x29780
movq %rcx, %rdx
shlq $0x4, %rdx
leaq 0x1963c(%rip), %rsi     # 0x30040
movq %rdi, 0x8(%rdx,%rsi)
xorl %eax, %eax
leaq 0x19646(%rip), %r8      # 0x30058
incl %eax
leaq 0x10(%r8), %r9
cmpq %rdi, (%r8)
movq %r9, %r8
jne 0x16a12
cmpl %eax, %ecx
jne 0x16a30
incl %ecx
movl %ecx, 0x12d54(%rip)     # 0x29780
andl $0x0, (%rdx,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: printtree1
static void printtree1(p, fd, lev)int fd,lev; Tree p; {
	int i;
	static char blanks[] = "                                         ";

	if (p == 0 || *printed(i = nodeid(p)))
		return;
	fprint(fd, "#%d%s%s", i, &"   "[i < 10 ? 0 : i < 100 ? 1 : 2],
		 &blanks[sizeof blanks - lev]);
	fprint(fd, "%s %t", opname(p->op), p->type);
	*printed(i) = 1;
	for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
		if (p->kids[i])
			fprint(fd, " #%d", nodeid(p->kids[i]));
	if (generic(p->op) == FIELD && p->u.field)
		fprint(fd, " %s %d..%d", p->u.field->name, p->u.field->from,
			p->u.field->to);
	else if (generic(p->op) == CNST)
		fprint(fd, " %s", vtoa(p->type, p->u.v));
	else if (p->u.sym)
		fprint(fd, " %s", p->u.sym->name);
	if (p->node)
		fprint(fd, " node=0x%x", p->node);
	fprint(fd, "\n");
	for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
		printtree1(p->kids[i], fd, lev + 1);
}

// Assembly:
testq %rdi, %rdi
je 0x16a99
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x169ef
movslq %eax, %rcx
shlq $0x4, %rcx
leaq 0x195b6(%rip), %r15     # 0x30040
cmpl $0x0, (%rcx,%r15)
je 0x16a9a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq %rcx, %r15
xorl %ecx, %ecx
cmpl $0x64, %eax
setge %cl
incq %rcx
cmpl $0xa, %eax
movl $0x0, %edx
cmovgeq %rcx, %rdx
leaq 0x5807(%rip), %rcx      # 0x1c2c2
addq %rdx, %rcx
movslq %ebx, %rdx
leaq 0x12cc8(%rip), %r8      # 0x29790
subq %rdx, %r8
addq $0x2a, %r8
leaq 0x8486(%rip), %rsi      # 0x1ef5c
movl %ebp, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x10528
movl (%r14), %edi
callq 0x166ad
movq 0x8(%r14), %rcx
leaq 0x8470(%rip), %rsi      # 0x1ef64
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10528
movl $0x1, (%r15)
pushq $0x2
popq %r12
leaq 0x57c0(%rip), %r15      # 0x1c2d2
cmpq $0x4, %r12
je 0x16b39
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x16b34
callq 0x169ef
movl %ebp, %edi
movq %r15, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x10528
incq %r12
jmp 0x16b12
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0x10, %eax
je 0x16b72
cmpl $0x2b0, %eax            # imm = 0x2B0
jne 0x16b8d
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x16baa
movq (%rax), %rdx
movswl 0x14(%rax), %ecx
movswl 0x16(%rax), %r8d
leaq 0x8403(%rip), %rsi      # 0x1ef6a
movl %ebp, %edi
xorl %eax, %eax
callq 0x10528
jmp 0x16baa
movq 0x8(%r14), %rdi
movq 0x28(%r14), %rsi
callq 0x13a68
leaq 0x8d8f(%rip), %rsi      # 0x1f915
movl %ebp, %edi
movq %rax, %rdx
jmp 0x16ba3
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x16baa
movq 0x10(%rax), %rdx
leaq 0x8d74(%rip), %rsi      # 0x1f915
movl %ebp, %edi
xorl %eax, %eax
callq 0x10528
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x16bc3
leaq 0x83bb(%rip), %rsi      # 0x1ef75
movl %ebp, %edi
xorl %eax, %eax
callq 0x10528
leaq 0x6fca(%rip), %rsi      # 0x1db94
xorl %r15d, %r15d
movl %ebp, %edi
xorl %eax, %eax
callq 0x10528
incl %ebx
cmpq $0x2, %r15
je 0x16a91
movq 0x10(%r14,%r15,8), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x16a63
incq %r15
jmp 0x16bd8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: tynode
static Type tynode(int op, Type type, int size, int align, Generic ptr)
{
	int i = (opindex(op)^((unsigned)type>>2))&(sizeof typetable/sizeof typetable[0]-1);
	struct type *tn;

	if (op != ARRAY || size > 0)
		for (tn = typetable[i]; tn; tn = tn->link)
			if (tn->type.op   == op   && tn->type.type  == type
			&&  tn->type.size == size && tn->type.align == align
			&&  tn->type.u.ptr == ptr)
				return &tn->type;
	tn = (struct type *) alloc(sizeof *tn);
	tn->type.op = op;
	tn->type.type = type;
	tn->type.size = size;
	tn->type.align = align;
	tn->type.u.ptr = ptr;
	BZERO((&tn->type.x), Xtype);
	tn->link = typetable[i];
	typetable[i] = tn;
	return &tn->type;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
movl %edi, %eax
shrl $0x4, %eax
movl %r15d, %ecx
shrl $0x2, %ecx
xorl %eax, %ecx
andl $0x7f, %ecx
cmpl $0xc, %edi
sete %al
testl %edx, %edx
setle %dl
movl %ecx, %r13d
leaq 0x1ad77(%rip), %rsi     # 0x32040
testb %dl, %al
jne 0x172fe
leaq (%rsi,%r13,8), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x172fe
cmpl %r12d, (%rax)
jne 0x172f8
cmpq %r15, 0x10(%rax)
jne 0x172f8
cmpl %r14d, 0x8(%rax)
jne 0x172f8
movswl 0x4(%rax), %ecx
cmpl %ebp, %ecx
jne 0x172f8
cmpq %rbx, 0x18(%rax)
je 0x1735b
addq $0x28, %rax
jmp 0x172d1
leaq 0x1246b(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x17322
movq %rdx, 0x8(%rcx)
jmp 0x17338
leaq 0x12447(%rip), %rsi     # 0x29770
pushq $0x30
popq %rdi
callq 0x16438
leaq 0x1ad08(%rip), %rsi     # 0x32040
movl %r12d, (%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x8(%rax)
movw %bp, 0x4(%rax)
movq %rbx, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq (%rsi,%r13,8), %rcx
movq %rcx, 0x28(%rax)
movq %rax, (%rsi,%r13,8)
addq $0x8, %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/types.c
// Function: array
Type array(Type ty, int n, int a) {
	if (ty && isfunc(ty)) {
		error("illegal type `array of %t'\n", ty);
		return array(inttype, n, 0);
	}
	if (a == 0)
		a = ty->align;
	if (level > GLOBAL && isarray(ty) && ty->size == 0)
		error("missing array size\n");
	if (ty->size == 0) {
		if (unqual(ty) == voidtype)
			error("illegal type `array of %t'\n", ty);
		else if (Aflag >= 2)
			warning("declaring type `array of %t' is undefined\n", ty);
	} else if (n > INT_MAX/ty->size) {
		error("size of `array of %t' exceeds %d bytes\n", ty, INT_MAX);
		n = 1;
	}
	return tynode(ARRAY, ty, n*ty->size, a, (Generic)0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x827b(%rip), %r15      # 0x1f612
testq %r14, %r14
je 0x173c7
movl (%r14), %eax
cmpl $0xf, %eax
jb 0x173aa
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0x173c7
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x8dd4
movq 0x1abd3(%rip), %r14     # 0x31f98
jmp 0x17397
testl %ebx, %ebx
jne 0x173d0
movswl 0x4(%r14), %ebx
leaq 0x17959(%rip), %rax     # 0x2ed30
cmpl $0x4, (%rax)
jl 0x17404
movl (%r14), %eax
cmpl $0xf, %eax
jb 0x173ea
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x17404
cmpl $0x0, 0x8(%r14)
jne 0x17404
leaq 0x8231(%rip), %rdi      # 0x1f62e
xorl %eax, %eax
callq 0x8dd4
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x17434
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
idivl %ecx
cmpl %ebp, %eax
jge 0x1747a
leaq 0x824d(%rip), %rdi      # 0x1f66d
movq %r14, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
callq 0x8dd4
pushq $0x1
popq %rbp
jmp 0x1747a
cmpl $0xf, (%r14)
movq %r14, %rax
jb 0x17441
movq 0x10(%r14), %rax
cmpq 0x1ab98(%rip), %rax     # 0x31fe0
je 0x17469
leaq 0x14607(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0x1747a
leaq 0x81e5(%rip), %rdi      # 0x1f642
movq %r14, %rsi
xorl %eax, %eax
callq 0x9239
jmp 0x1747a
leaq 0x81a2(%rip), %rdi      # 0x1f612
movq %r14, %rsi
xorl %eax, %eax
callq 0x8dd4
imull 0x8(%r14), %ebp
pushq $0xc
popq %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1728b
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: atop
Type atop(ty) Type ty; {
	if (isarray(ty))
		return ptr(ty->type);
	error("type error: %s\n", "array expected");
	return ptr(ty);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x174ac
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x174b7
movq 0x10(%rbx), %rdi
jmp 0x174cf
leaq 0x81d7(%rip), %rdi      # 0x1f695
leaq 0x81e0(%rip), %rsi      # 0x1f6a5
xorl %eax, %eax
callq 0x8dd4
movq %rbx, %rdi
popq %rbx
jmp 0x1736a
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: checkfields
void checkfields(ty) Type ty; {
	Field p, inherited = 0;

	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, ty, inherited, p->offset);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x58, %r14
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0x1750d
cmpq $0x0, (%r14)
jne 0x17507
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x17515
addq $0x18, %r14
jmp 0x174e6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: check
static Field check(ty, top, inherited, off) Type ty, top; Field inherited; int off; {
	Field p;

	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name && isfield(p->name, inherited))
			error("ambiguous field `%s' of `%t' from `%t'\n", p->name, top, ty);
		else if (p->name && !isfield(p->name, top->u.sym->u.s.flist)) {
			Field new = (Field) talloc(sizeof *new);
			*new = *p;
			new->offset = off + p->offset;
			new->link = inherited;
			inherited = new;
		}
	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, top, inherited,
				off + p->offset);
	return inherited;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x18(%rdi), %rbp
addq $0x58, %rbp
leaq 0x1223c(%rip), %rsi     # 0x29778
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x175ec
movq (%rbp), %r13
testq %r13, %r13
je 0x17596
movq %rsi, %rbx
movq %r13, %rdi
movq %r15, %rsi
callq 0x1800d
testq %rax, %rax
je 0x1757e
leaq 0x83b9(%rip), %rdi      # 0x1f925
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x8dd4
jmp 0x17593
movq 0x18(%r14), %rax
movq 0x58(%rax), %rsi
movq %r13, %rdi
callq 0x1800d
testq %rax, %rax
je 0x1759c
movq %rbx, %rsi
addq $0x18, %rbp
jmp 0x1753c
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x175bc
movq %rbx, %rsi
movq %rdx, 0x8(%rcx)
jmp 0x175ca
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x16438
movq %rbx, %rsi
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl 0x10(%rbp), %ecx
addl 0x4(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rax, %r15
jmp 0x17596
movq 0x18(%r12), %r12
addq $0x58, %r12
movl 0x4(%rsp), %ebx
movq (%r12), %r12
testq %r12, %r12
je 0x17629
cmpq $0x0, (%r12)
jne 0x17623
movq 0x8(%r12), %rdi
movl 0x10(%r12), %ecx
addl %ebx, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0x17515
movq %rax, %r15
addq $0x18, %r12
jmp 0x175f9
movq %r15, %rax
addq $0x8, %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/types.c
// Function: qual
Type qual(int op, Type ty) {
	if (isarray(ty))
		ty = tynode(ARRAY, qual(op, ty->type), ty->size,
			ty->align, 0);
	else if (isfunc(ty))
		warning("qualified function type ignored\n");
	else if ((isconst(ty) && op == CONST) || (isvolatile(ty) && op == VOLATILE))
		error("illegal type `%k %t'\n", op, ty);
	else {
		int i;
		struct type *tn;
		if (isqual(ty)) {
			op += ty->op;
			ty = ty->type;
		}
		for (i = 0; i < sizeof typetable/sizeof typetable[0]; i++)
			for (tn = typetable[i]; tn; tn = tn->link)
				if (tn->type.op == op && tn->type.type == ty) {
					tn->type.size = ty->size;
					tn->type.align = ty->align;
					return &tn->type;
				}
		return tynode(op, ty, ty->size, ty->align, 0);
	}
	return ty;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl %edi, %eax
movl (%rsi), %ecx
cmpl $0xf, %ecx
jb 0x178d4
movq 0x10(%rbx), %rsi
movl (%rsi), %edx
cmpl $0xc, %edx
je 0x178df
jmp 0x178fc
movl %ecx, %edx
cmpl $0xc, %ecx
jne 0x178fc
movq 0x10(%rbx), %rsi
movl %eax, %edi
callq 0x178ba
movl 0x8(%rbx), %edx
movswl 0x4(%rbx), %ecx
pushq $0xc
popq %rdi
movq %rax, %rsi
xorl %r8d, %r8d
popq %rbx
jmp 0x1728b
cmpl $0xb, %edx
jne 0x17911
leaq 0x7f6d(%rip), %rdi      # 0x1f875
xorl %eax, %eax
callq 0x9239
jmp 0x17985
cmpl $0xf, %ecx
jne 0x17954
cmpl $0xf, %eax
je 0x17962
addl %ecx, %eax
movq 0x10(%rbx), %rsi
xorl %ecx, %ecx
leaq 0x1a716(%rip), %rdx     # 0x32040
cmpq $0x80, %rcx
je 0x179b0
leaq (%rdx,%rcx,8), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1794f
cmpl %eax, (%rbx)
jne 0x17949
cmpq %rsi, 0x10(%rbx)
je 0x17977
addq $0x28, %rbx
jmp 0x17937
incq %rcx
jmp 0x1792a
movl %ecx, %edx
xorl $0x1f, %edx
movl %eax, %esi
xorl $0xf, %esi
orl %edx, %esi
jne 0x1798a
leaq 0x7f2d(%rip), %rdi      # 0x1f896
movl %eax, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8dd4
jmp 0x17985
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
movzwl 0x4(%rsi), %eax
movw %ax, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq
cmpl $0x10, %ecx
jne 0x17996
cmpl $0x10, %eax
jne 0x1791b
jmp 0x17962
movl %eax, %esi
xorl $0x10, %esi
orl %edx, %esi
je 0x17962
cmpl $0xf, %ecx
jae 0x1791b
movq %rbx, %rsi
jmp 0x17921
movl 0x8(%rsi), %edx
movswl 0x4(%rsi), %ecx
movl %eax, %edi
jmp 0x178f3
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: deftype
Symbol deftype(name, ty, pos) char *name; Type ty; Coordinate *pos; {
	Symbol p = lookup(name, identifiers);

	if (p && p->scope == level)
		error("redeclaration of `%s'\n", name);
	p = install(name, &identifiers, level < LOCAL);
	p->type = ty;
	p->sclass = TYPEDEF;
	p->src = *pos;
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1185d(%rip), %rax     # 0x292e8
movq (%rax), %rsi
callq 0x15ec0
leaq 0x17296(%rip), %r12     # 0x2ed30
movl (%r12), %ecx
testq %rax, %rax
je 0x17ac0
movzwl 0x18(%rax), %eax
cmpl %eax, %ecx
jne 0x17ac0
leaq 0x7c13(%rip), %rdi      # 0x1f6c5
movq %r15, %rsi
xorl %eax, %eax
callq 0x8dd4
movl (%r12), %ecx
xorl %edx, %edx
cmpl $0x5, %ecx
setl %dl
leaq 0x11819(%rip), %rsi     # 0x292e8
movq %r15, %rdi
callq 0x15f13
movq %r14, 0x20(%rax)
movb $0x53, 0x1a(%rax)
movups (%rbx), %xmm0
movups %xmm0, 0x28(%rax)
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/types.c
// Function: deref
Type deref(ty) Type ty; {
	if (isptr(ty))
		ty = ty->type;
	else
		error("type error: %s\n", "pointer expected");
	return isenum(ty) ? unqual(ty)->type : ty;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x17b03
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x17b0e
movq 0x10(%rbx), %rbx
jmp 0x17b23
leaq 0x7b80(%rip), %rdi      # 0x1f695
leaq 0x7bc0(%rip), %rsi      # 0x1f6dc
xorl %eax, %eax
callq 0x8dd4
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0x17b35
movq 0x10(%rbx), %rax
cmpl $0xd, (%rax)
je 0x17b3d
jmp 0x17b41
movq %rbx, %rax
cmpl $0xd, %ecx
jne 0x17b41
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: extends
Field extends(ty, fty) Type ty, fty; {
	Field p, q;

	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0 && unqual(p->type) == unqual(fty))
			return p;
		else if (p->name == 0 && (q = extends(p->type, fty))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0xf, (%rdi)
jb 0x17cdb
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %rbx
addq $0x58, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x17d26
cmpq $0x0, (%rbx)
jne 0x17d20
movq 0x8(%rbx), %rdi
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x17d01
movq 0x10(%rdi), %rax
cmpl $0xf, (%r14)
movq %r14, %rcx
jb 0x17d0e
movq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0x17d52
movq %r14, %rsi
callq 0x17ccb
testq %rax, %rax
jne 0x17d2a
addq $0x18, %rbx
jmp 0x17ce3
xorl %ebx, %ebx
jmp 0x17d52
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x1a2d0(%rip)    # 0x32008
movups %xmm0, 0x1a2b9(%rip)    # 0x31ff8
movl 0x10(%rax), %eax
addl 0x10(%rbx), %eax
leaq 0x1a2ac(%rip), %rbx     # 0x31ff8
movl %eax, 0x1a2b6(%rip)     # 0x32008
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: fieldlist
Field fieldlist(ty) Type ty; {
	Field p, q, t, inherited = 0, *r;

	ty = unqual(ty);
	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, ty, inherited, p->offset);
	if (inherited == 0)
		return ty->u.sym->u.s.flist;
	for (q = 0, p = inherited; p; q = p, p = t) {
		t = p->link;
		p->link = q;
	}
	for (r = &inherited, p = ty->u.sym->u.s.flist; p && q; )
		if (p->name == 0)
			p = p->link;
		else if (p->offset <= q->offset) {
			*r = (Field) talloc(sizeof **r);
			**r = *p;
			r = &(*r)->link;
			p = p->link;
		} else {
			*r = q;
			r = &q->link;
			q = q->link;
		}
	for ( ; p; p = p->link)
		if (p->name) {
			*r = (Field) talloc(sizeof **r);
			**r = *p;
			r = &(*r)->link;
		}
	*r = q;
	return inherited;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xf, (%rdi)
jb 0x17d75
movq 0x10(%rbx), %rbx
movq 0x18(%rbx), %r14
addq $0x58, %r14
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0x17da6
cmpq $0x0, (%r14)
jne 0x17da0
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x17515
addq $0x18, %r14
jmp 0x17d7f
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x17ec4
xorl %r14d, %r14d
testq %rax, %rax
je 0x17dcc
movq %rax, %rcx
movq 0x18(%rax), %rax
movq %r14, 0x18(%rcx)
movq %rcx, %r14
jmp 0x17db7
movq 0x18(%rbx), %r15
addq $0x58, %r15
leaq 0x8(%rsp), %r12
leaq 0x11998(%rip), %rbx     # 0x29778
pushq $0x20
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0x17eb4
testq %r14, %r14
je 0x17eb4
cmpq $0x0, (%r15)
je 0x17e5c
movl 0x10(%r15), %eax
cmpl 0x10(%r14), %eax
jle 0x17e19
movq %r14, (%r12)
movq %r14, %r12
movq 0x18(%r14), %r14
addq $0x18, %r12
jmp 0x17de6
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x17e36
movq %rdx, 0x8(%rcx)
jmp 0x17e40
movl %ebp, %edi
movq %rbx, %rsi
callq 0x16438
movq %rax, (%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
addq $0x18, %r15
jmp 0x17de3
cmpq $0x0, (%r15)
je 0x17eb0
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x17e85
movq %rdx, 0x8(%rcx)
jmp 0x17e94
leaq 0x118ec(%rip), %rsi     # 0x29778
pushq $0x20
popq %rdi
callq 0x16438
movq %rax, (%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x17e62
movq %r14, (%r12)
leaq 0x8(%rsp), %rax
jmp 0x17ecc
movq 0x18(%rbx), %rax
addq $0x58, %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: fieldref
Field fieldref(name, ty) char *name; Type ty; {
	Field p = isfield(name, unqual(ty)->u.sym->u.s.flist);
	if (p) {
		if (xref) {
			Symbol q;
			assert(unqual(ty)->u.sym->u.s.ftab);
			q = lookup(name, unqual(ty)->u.sym->u.s.ftab);
			assert(q);
			use(q, src);
		}
		return p;
	}
	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link) {
		Field q;
		if (p->name == 0 && (q = fieldref(name, p->type))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %ebp
movq %rsi, %rax
cmpl $0xf, %ebp
jb 0x17ef7
movq 0x10(%r15), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rsi
movq %r14, %rdi
callq 0x1800d
testq %rax, %rax
je 0x17f2e
movq %rax, %rbx
leaq 0x13b1e(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x17fc1
cmpl $0xf, %ebp
jb 0x17f66
movq 0x10(%r15), %rax
movq 0x18(%rax), %rax
jmp 0x17f6a
cmpl $0xf, %ebp
jb 0x17f37
movq 0x10(%r15), %r15
movq 0x18(%r15), %r15
addq $0x58, %r15
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x17fc1
cmpq $0x0, (%r15)
jne 0x17f60
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x17edc
testq %rax, %rax
jne 0x17f98
addq $0x18, %r15
jmp 0x17f41
movq 0x18(%r15), %rax
movq 0x50(%rax), %rsi
testq %rsi, %rsi
je 0x17fcf
movq %r14, %rdi
callq 0x15ec0
testq %rax, %rax
je 0x17fee
leaq 0x139b1(%rip), %rcx     # 0x2b938
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x163c8
jmp 0x17fc1
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x1a082(%rip)    # 0x32028
movups %xmm0, 0x1a06b(%rip)    # 0x32018
leaq 0x1a064(%rip), %rbx     # 0x32018
movl 0x10(%rax), %eax
addl 0x10(%r15), %eax
movl %eax, 0x1a067(%rip)     # 0x32028
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7724(%rip), %rdi      # 0x1f6fa
leaq 0x724b(%rip), %rsi      # 0x1f228
leaq 0x7732(%rip), %rcx      # 0x1f716
movl $0x13d, %edx            # imm = 0x13D
callq 0x30d0
leaq 0x5264(%rip), %rdi      # 0x1d259
leaq 0x722c(%rip), %rsi      # 0x1f228
leaq 0x7713(%rip), %rcx      # 0x1f716
movl $0x13f, %edx            # imm = 0x13F
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: isfield
static Field isfield(name, flist) char *name; Field flist; {
	for ( ; flist; flist = flist->link)
		if (flist->name == name)
			break;
	return flist;
}

// Assembly:
movq %rsi, %rax
testq %rax, %rax
je 0x18020
cmpq %rdi, (%rax)
je 0x18020
movq 0x18(%rax), %rax
jmp 0x18010
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: hasproto
int hasproto(ty) Type ty; {
	if (Aflag < 1 || ty == 0)
		return 1;
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE: case POINTER:
	case ARRAY:
		return hasproto(ty->type);
	case FUNCTION:
		return hasproto(ty->type) && ty->u.proto;
	case STRUCT: case UNION:
	case CHAR:   case SHORT: case INT:  case DOUBLE:
	case VOID:   case FLOAT: case ENUM: case UNSIGNED:
		return 1;
	default:
		assert(0);
	}
	return 0;
}

// Assembly:
pushq %rbx
leaq 0x139f5(%rip), %rcx     # 0x2ba58
pushq $0x1
popq %rax
cmpl $0x0, (%rcx)
jle 0x18094
movq %rdi, %rbx
movl $0x80019080, %ecx       # imm = 0x80019080
testq %rbx, %rbx
je 0x18094
movl (%rbx), %edx
cmpl $0x1f, %edx
ja 0x180b8
btl %edx, %ecx
jae 0x1808a
movq 0x10(%rbx), %rbx
jmp 0x18073
movl $0x277e, %ecx           # imm = 0x277E
btl %edx, %ecx
jae 0x18096
popq %rbx
retq
cmpl $0xb, %edx
jne 0x180b8
movq 0x10(%rbx), %rdi
callq 0x1805b
testl %eax, %eax
je 0x180b4
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
setne %al
jmp 0x18094
xorl %eax, %eax
jmp 0x18094
leaq 0x40dc(%rip), %rdi      # 0x1c19b
leaq 0x7162(%rip), %rsi      # 0x1f228
leaq 0x7686(%rip), %rcx      # 0x1f753
movl $0x173, %edx            # imm = 0x173
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newfield
Field newfield(name, ty, fty) char *name; Type ty, fty; {
	Field p, *q = &ty->u.sym->u.s.flist;

	if (name == 0)
		name = stringd(genlabel(1));
	for (p = *q; p; q = &p->link, p = *q)
		if (p->name == name)
			error("duplicate field name `%s' in `%t'\n", name, ty);
	*q = p = (Field)alloc(sizeof *p);
	BZERO(p, struct field);
	p->name = name;
	p->type = fty;
	if (xref) {
		if (ty->u.sym->u.s.ftab == 0)
			ty->u.sym->u.s.ftab = table(0, level);
		install(name, &ty->u.sym->u.s.ftab, 1)->src = src;
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r13
testq %rdi, %rdi
jne 0x18106
pushq $0x1
popq %rdi
callq 0x1616e
movl %eax, %edi
callq 0x159ba
movq %rax, %r14
addq $0x58, %r13
leaq 0x7651(%rip), %r12      # 0x1f762
movq (%r13), %rbp
testq %rbp, %rbp
je 0x18139
cmpq %r14, (%rbp)
jne 0x18130
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8dd4
addq $0x18, %rbp
movq %rbp, %r13
jmp 0x18111
leaq 0x11630(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x20, (%rax)
movq 0x8(%rax), %r12
leaq 0x20(%r12), %rcx
cmpq 0x10(%rax), %rcx
jae 0x1815e
movq %rcx, 0x8(%rax)
jmp 0x18170
leaq 0x1160b(%rip), %rsi     # 0x29770
pushq $0x20
popq %rdi
callq 0x16438
movq %rax, %r12
movq %r12, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %r14, (%r12)
movq %r15, 0x8(%r12)
leaq 0x138a7(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x181d6
movq 0x18(%rbx), %rsi
cmpq $0x0, 0x50(%rsi)
jne 0x181b9
leaq 0x16b8c(%rip), %rax     # 0x2ed30
movl (%rax), %esi
xorl %edi, %edi
callq 0x1617d
movq 0x18(%rbx), %rcx
movq %rax, 0x50(%rcx)
movq 0x18(%rbx), %rsi
addq $0x50, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x15f13
leaq 0x13769(%rip), %rcx     # 0x2b938
movups (%rcx), %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, %rax
addq $0x8, %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/types.c
// Function: newstruct
Type newstruct(op, tag) int op; char *tag; {
	Symbol p;

	if (!tag || *tag == '\0')  /* anonymous structure/union/enum */
		tag = stringd(genlabel(1));
	if ((p = lookup(tag, types)) && (p->scope == level
	|| (p->scope == PARAM && level == PARAM+1))) {
		if (p->type->op == op && !p->defined)
			return p->type;
		error("redeclaration of `%s'\n", tag);
	}
	p = install(tag, &types, 1);
	p->type = tynode(op, 0, 0, 0, p);
	if (p->scope > maxlevel)
		maxlevel = p->scope;
	p->src = src;
	return p->type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testq %rsi, %rsi
je 0x181fb
movq %rsi, %r14
cmpb $0x0, (%rsi)
jne 0x1820d
pushq $0x1
popq %rdi
callq 0x1616e
movl %eax, %edi
callq 0x159ba
movq %rax, %r14
leaq 0x114fc(%rip), %rax     # 0x29710
movq (%rax), %rsi
movq %r14, %rdi
callq 0x15ec0
testq %rax, %rax
je 0x18265
movzwl 0x18(%rax), %edx
leaq 0x16b01(%rip), %rcx     # 0x2ed30
movl (%rcx), %ecx
cmpl %edx, %ecx
je 0x18246
cmpw $0x4, %dx
setne %dl
cmpl $0x5, %ecx
setne %cl
orb %dl, %cl
jne 0x18265
movq 0x20(%rax), %rcx
cmpl %ebx, (%rcx)
jne 0x18254
testb $0x1, 0x1b(%rax)
je 0x182b3
leaq 0x746a(%rip), %rdi      # 0x1f6c5
movq %r14, %rsi
xorl %eax, %eax
callq 0x8dd4
leaq 0x114a4(%rip), %rsi     # 0x29710
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x15f13
movq %rax, %r14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x1728b
movq %rax, %rcx
movq %rax, 0x20(%r14)
movzwl 0x18(%r14), %eax
cmpl %eax, 0x19d9c(%rip)     # 0x32038
jge 0x182a4
movl %eax, 0x19d94(%rip)     # 0x32038
leaq 0x1368d(%rip), %rax     # 0x2b938
movups (%rax), %xmm0
movups %xmm0, 0x28(%r14)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printdecl
void printdecl(p, ty) Symbol p; Type ty; {
	switch (p->sclass) {
	case AUTO:
		fprint(2, "%s;\n", typestring(ty, p->name));
		break;
	case STATIC: case EXTERN:
		fprint(2, "%k %s;\n", p->sclass, typestring(ty, p->name));
	case TYPEDEF: case ENUM:
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbx
movzbl 0x1a(%rdi), %ebx
cmpl $0xd, %ebx
je 0x1858e
cmpl $0x53, %ebx
je 0x1858e
cmpl $0x4a, %ebx
je 0x18590
cmpl $0x51, %ebx
je 0x18590
cmpl $0x43, %ebx
jne 0x185b6
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x185d5
leaq 0x7290(%rip), %rsi      # 0x1f810
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x10528
popq %rbx
retq
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x185d5
leaq 0x7267(%rip), %rsi      # 0x1f80d
pushq $0x2
popq %rdi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x10528
leaq 0x3bde(%rip), %rdi      # 0x1c19b
leaq 0x6c64(%rip), %rsi      # 0x1f228
leaq 0x724a(%rip), %rcx      # 0x1f815
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printproto
void printproto(p, callee) Symbol p, callee[]; {
	if (p->type->u.proto)
		printdecl(p, p->type);
	else {
		int i;
		List list = 0;
		if (callee[0] == 0)
			list = append(voidtype, list);
		else
			for (i = 0; callee[i]; i++)
				list = append(callee[i]->type, list);
		printdecl(p, funcl(freturn(p->type), list));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x18956
movq %rbx, %rdi
jmp 0x189ad
movq (%r14), %rax
testq %rax, %rax
je 0x18982
addq $0x8, %r14
xorl %r15d, %r15d
testq %rax, %rax
je 0x18993
movq 0x20(%rax), %rdi
movq %r15, %rsi
callq 0x156a0
movq %rax, %r15
movq (%r14), %rax
addq $0x8, %r14
jmp 0x18965
movq 0x19657(%rip), %rdi     # 0x31fe0
xorl %esi, %esi
callq 0x156a0
movq %rax, %r15
movq 0x20(%rbx), %rdi
callq 0x18021
movq %rax, %rdi
movq %r15, %rsi
callq 0x17a0f
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1854c
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printtype
void printtype(Type ty, int fd) {
	switch (ty->op) {
	case STRUCT: case UNION: {
		Field p;
		fprint(fd, "%k %s size=%d {\n", ty->op, ty->u.sym->name, ty->size);
		for (p = ty->u.sym->u.s.flist; p; p = p->link) {
			fprint(fd, "field %s: offset=%d", p->name, p->offset);
			if (p->to)
				fprint(fd, " bits=%d..%d", p->from, p->to);
			fprint(fd, " type=%t", p->type);
		}
		fprint(fd, "}\n");
		break;
		}
	case ENUM: {
		int i;
		Symbol p;
		fprint(fd, "enum %s {", ty->u.sym->name);
		for (i = 0; (p = ty->u.sym->u.idlist[i]); i++) {
			if (i > 0)
				fprint(fd, ",");
			fprint(fd, "%s=%d", p->name, p->u.value);
		}
		fprint(fd, "}\n");
		break;
		}
	default:
		fprint(fd, "%t\n", ty);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jae 0x18a5f
movq 0x18(%r14), %rax
movq 0x10(%rax), %rcx
movl 0x8(%r14), %r8d
leaq 0x6e3e(%rip), %rsi      # 0x1f826
movl %ebx, %edi
xorl %eax, %eax
callq 0x10528
movq 0x18(%r14), %r13
addq $0x58, %r13
leaq 0x6e37(%rip), %r14      # 0x1f837
leaq 0x6e51(%rip), %r15      # 0x1f858
leaq 0x6e3d(%rip), %r12      # 0x1f84b
movq (%r13), %r13
testq %r13, %r13
je 0x18acc
movq (%r13), %rdx
movl 0x10(%r13), %ecx
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10528
movswl 0x16(%r13), %ecx
testl %ecx, %ecx
je 0x18a49
movswl 0x14(%r13), %edx
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x10528
movq 0x8(%r13), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10528
addq $0x18, %r13
jmp 0x18a0e
cmpl $0xd, %edx
jne 0x18aea
movq 0x18(%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x6dea(%rip), %rsi      # 0x1f861
movl %ebx, %edi
xorl %eax, %eax
callq 0x10528
leaq 0x6de4(%rip), %r15      # 0x1f86b
leaq 0x5524(%rip), %r12      # 0x1dfb2
xorl %r13d, %r13d
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
movq (%rax,%r13), %rbp
testq %rbp, %rbp
je 0x18acc
testq %r13, %r13
je 0x18ab3
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x10528
movq 0x10(%rbp), %rdx
movl 0x48(%rbp), %ecx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10528
addq $0x8, %r13
jmp 0x18a91
leaq 0x54bc(%rip), %rsi      # 0x1df8f
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
leaq 0x6d80(%rip), %rsi      # 0x1f871
movl %ebx, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10528
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: rmtypes
void rmtypes() {
	if (maxlevel >= level) {
		int i;
		maxlevel = 0;
		for (i = 0; i < sizeof typetable/sizeof typetable[0]; i++) {
			struct type *tn, **tq = &typetable[i];
			for (tn = *tq; tn; tn = *tq)
				if (tn->type.op == FUNCTION)
					tq = &tn->link;
				else if (tn->type.u.sym && tn->type.u.sym->scope == level)
					*tq = tn->link;
				else {
					if (tn->type.u.sym && tn->type.u.sym->scope > maxlevel)
						maxlevel = tn->type.u.sym->scope;
					tq = &tn->link;
				}
		}
	}
}

// Assembly:
leaq 0x1621e(%rip), %rax     # 0x2ed30
movl (%rax), %eax
cmpl %eax, 0x1951e(%rip)     # 0x32038
jge 0x18b1d
retq
andl $0x0, 0x19514(%rip)     # 0x32038
xorl %ecx, %ecx
leaq 0x19513(%rip), %rdx     # 0x32040
xorl %esi, %esi
cmpq $0x80, %rcx
je 0x18b1c
leaq (%rdx,%rcx,8), %rdi
movq %rdi, %r8
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x18b7d
cmpl $0xb, (%rdi)
je 0x18b77
movq 0x18(%rdi), %r9
testq %r9, %r9
je 0x18b77
movzwl 0x18(%r9), %r9d
cmpl %r9d, %eax
jne 0x18b68
movq 0x28(%rdi), %rdi
movq %rdi, (%r8)
jmp 0x18b42
cmpl %r9d, %esi
jge 0x18b77
movl %r9d, 0x194c4(%rip)     # 0x32038
movl %r9d, %esi
addq $0x28, %rdi
jmp 0x18b3c
incq %rcx
jmp 0x18b2f
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: ttob
int ttob(ty) Type ty; {
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE:
		return ttob(ty->type);
	case VOID: case CHAR: case INT: case SHORT:
	case UNSIGNED: case FLOAT: case DOUBLE:
		return ty->op;
	case POINTER: case FUNCTION:
		return POINTER;
	case ARRAY: case STRUCT: case UNION:
		return STRUCT;
	case ENUM:
		return INT;
	default:
		assert(0);
	}
	return I;
}

// Assembly:
pushq %rax
leaq 0x65e6(%rip), %rcx      # 0x1f170
movl (%rdi), %eax
leal -0x1(%rax), %edx
cmpl $0x1e, %edx
ja 0x18bb0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq 0x10(%rdi), %rdi
jmp 0x18b8a
pushq $0x9
jmp 0x18bad
pushq $0x7
jmp 0x18bad
pushq $0x5
popq %rax
popq %rcx
retq
leaq 0x35e4(%rip), %rdi      # 0x1c19b
leaq 0x666a(%rip), %rsi      # 0x1f228
leaq 0x6ce7(%rip), %rcx      # 0x1f8ac
movl $0x26c, %edx            # imm = 0x26C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: variadic
int variadic(ty) Type ty; {
	if (isfunc(ty) && ty->u.proto) {
		int i;
		for (i = 0; ty->u.proto[i]; i++)
			;
		return i > 1 && ty->u.proto[i-1] == voidtype;
	}
	return 0;
}

// Assembly:
movl (%rdi), %ecx
cmpl $0xf, %ecx
jb 0x18bdc
movq 0x10(%rdi), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl $0xb, %ecx
jne 0x18c12
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x18c12
pushq $-0x1
popq %rdx
cmpq $0x0, 0x8(%rcx,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x18bef
cmpq $0x2, %rdx
jb 0x18c12
movq -0x8(%rcx,%rdx,8), %rcx
xorl %eax, %eax
cmpq 0x193d1(%rip), %rcx     # 0x31fe0
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: print_node
void print_node(Node p) {
    fprintf(stderr,"Node %s%c\n",
            opcode_names[generic(p->op)>>4], type_name[optype(p->op)]);
    fprintf(stderr,"Node addr: %p\n", p);
    fprintf(stderr,"  optimized: %d\n", p->x.optimized);
    fprintf(stderr,"  referenced: %d\n", p->count);
    fprintf(stderr,"  Operator = %d\n", p->op);
    fprintf(stderr,"  link to next dag:  %p\n", p->link);
    fprintf(stderr,"  next on linearized list: %p\n", p->x.next);
    fprintf(stderr,"  syms[0]: %p\n", p->syms[0]);
    fprintf(stderr,"  syms[1]: %p\n", p->syms[1]);
    fprintf(stderr,"  kids[0]: %p\n", p->kids[0]);
    fprintf(stderr,"  kids[1]: %p\n", p->kids[1]);
    fprintf(stderr,"  result: %p\n",  p->x.result);
    fprintf(stderr,"  adrmode: %c\n", p->x.adrmode);
    fprintf(stderr,"  name: %s\n",    p->x.name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf3ce(%rip), %r14      # 0x27ff0
movq (%r14), %rdi
movl (%rbx), %eax
movl %eax, %ecx
shrl $0x4, %ecx
leaq 0xf07d(%rip), %rdx      # 0x27cb0
movq (%rdx,%rcx,8), %rdx
andl $0xf, %eax
leaq 0x7bff(%rip), %rcx      # 0x20840
movsbl (%rax,%rcx), %ecx
leaq 0x7219(%rip), %rsi      # 0x1fe65
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
leaq 0x7213(%rip), %rsi      # 0x1fe70
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movsbl 0x60(%rbx), %edx
leaq 0x720a(%rip), %rsi      # 0x1fe7f
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movswl 0x4(%rbx), %edx
leaq 0x7206(%rip), %rsi      # 0x1fe90
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movl (%rbx), %edx
leaq 0x7205(%rip), %rsi      # 0x1fea2
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x30(%rbx), %rdx
leaq 0x7201(%rip), %rsi      # 0x1feb3
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x58(%rbx), %rdx
leaq 0x7205(%rip), %rsi      # 0x1fecc
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x8(%rbx), %rdx
leaq 0x720f(%rip), %rsi      # 0x1feeb
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x10(%rbx), %rdx
leaq 0x7209(%rip), %rsi      # 0x1fefa
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x20(%rbx), %rdx
leaq 0x7203(%rip), %rsi      # 0x1ff09
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x28(%rbx), %rdx
leaq 0x71fd(%rip), %rsi      # 0x1ff18
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x48(%rbx), %rdx
leaq 0x71f7(%rip), %rsi      # 0x1ff27
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movsbl 0x40(%rbx), %edx
leaq 0x71f0(%rip), %rsi      # 0x1ff35
xorl %eax, %eax
callq 0x3120
movq (%r14), %rdi
movq 0x38(%rbx), %rdx
leaq 0x71ea(%rip), %rsi      # 0x1ff44
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defsymbol
void defsymbol(Symbol p) {
    if (p->x.name) return;
    if (p->scope == CONSTANTS) {
        p->x.name = p->name;
        if (p->x.name[0]=='0' && p->x.name[1]=='x') {
            p->x.name[0]=' '; p->x.name[1]='$';
        }
    } else if (p->sclass == STATIC)
        p->x.name = stringf("L%s%d", NamePrefix, genlabel(1));
    else if (p->generated)
        p->x.name = stringf("L%s%s", NamePrefix, p->name);
    else
        p->x.name = stringf("_%s", p->name);
    p->x.adrmode = 'C';

}

// Assembly:
cmpq $0x0, (%rdi)
je 0x18f74
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x18(%rdi)
jne 0x18fa0
movq 0x10(%rbx), %rax
movq %rax, (%rbx)
cmpb $0x30, (%rax)
jne 0x19000
cmpb $0x78, 0x1(%rax)
jne 0x19000
movb $0x20, (%rax)
movq (%rbx), %rax
movb $0x24, 0x1(%rax)
jmp 0x19000
cmpb $0x51, 0x1a(%rbx)
jne 0x18fca
movq 0x19493(%rip), %r14     # 0x32440
pushq $0x1
popq %rdi
callq 0x1616e
leaq 0x6fc3(%rip), %rdi      # 0x1ff7f
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x10a97
jmp 0x18ffd
testb $0x4, 0x1b(%rbx)
jne 0x18fe4
movq 0x10(%rbx), %rsi
leaq 0x6fb0(%rip), %rdi      # 0x1ff8b
xorl %eax, %eax
callq 0x10a97
jmp 0x18ffd
movq 0x19455(%rip), %rsi     # 0x32440
movq 0x10(%rbx), %rdx
leaq 0x6f8f(%rip), %rdi      # 0x1ff85
xorl %eax, %eax
callq 0x10a97
movq %rax, (%rbx)
movb $0x43, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: printfloat
void printfloat(double val)
{
    int i,exp=32,negative=0;
    double two_pow31,two_pow32;
    unsigned long mantissa;

    if (val==0.0) {
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        return;
    }
    if (val<0.0) { negative=1; val= -val; }
    for (two_pow31=1.0,i=0;i<31;i++) two_pow31*=2;
    two_pow32=two_pow31*2;
    while (val>=two_pow32) {
        val/=2;
        exp++;
    }
    while (val<two_pow31) {
        val*=2;
        exp--;
    }
    if (!negative) val-=two_pow31;
    mantissa=val;
    print("\tDB($%x)\n",exp+128);
    print("\tDB($%x)\n",(mantissa>>24)&0xFF);
    print("\tDB($%x)\n",(mantissa>>16)&0xFF);
    print("\tDB($%x)\n",(mantissa>>8)&0xFF);
    print("\tDB($%x)\n",mantissa&0xFF);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x19077
jp 0x19077
leaq 0x6f4e(%rip), %rbx      # 0x1ff8f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x106a9
movapd 0x51f1(%rip), %xmm3     # 0x1e270
xorpd %xmm0, %xmm3
movsd 0x51cd(%rip), %xmm1     # 0x1e258
pushq $0x1f
popq %rax
subl $0x1, %eax
jb 0x19099
addsd %xmm1, %xmm1
jmp 0x1908e
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
cmpnltsd %xmm4, %xmm2
movapd %xmm2, %xmm4
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
movapd %xmm1, %xmm3
addsd %xmm1, %xmm3
movl $0xa0, %esi
movsd 0x6885(%rip), %xmm4     # 0x1f950
ucomisd %xmm3, %xmm2
jb 0x190df
mulsd %xmm4, %xmm2
incl %esi
jmp 0x190cb
addsd %xmm2, %xmm2
decl %esi
ucomisd %xmm2, %xmm1
ja 0x190d9
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
cmpnltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x6842(%rip), %xmm0     # 0x1f958
cvttsd2si %xmm0, %r14
andq %rcx, %r14
orq %rax, %r14
leaq 0x6e6f(%rip), %rbx      # 0x1ff97
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movl %r14d, %esi
shrl $0x10, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movl %r14d, %esi
shrl $0x8, %esi
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x106a9
movzbl %r14b, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x106a9
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defconst
void defconst(int ty, Value v) {
    if (graph_output) return;
    switch (ty) {
    case C: print("\tDB(%d)\n",   v.uc); break;
    case S: print("\tDB(%d)\n",   v.us); break;
    case I: print("\tDW(%d)\n",   v.i ); break;
    case U: print("\tDW($%x)\n",  v.u ); break;
    case P: print("\tDW($%x)\n",  v.p ); break;
    case F: printfloat(v.f); break;
    case D: printfloat(v.d); break;
    default: assert(0);
    }
}

// Assembly:
cmpb $0x0, 0x192c4(%rip)     # 0x32448
je 0x19187
retq
decl %edi
cmpl $0x6, %edi
ja 0x191df
movq %rsi, %xmm0
leaq 0x67c6(%rip), %rax      # 0x1f960
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
jmp 0x1902a
leaq 0x6dfb(%rip), %rdi      # 0x1ffaa
jmp 0x191ca
movzbl %sil, %esi
jmp 0x191ba
movzwl %si, %esi
leaq 0x6de0(%rip), %rdi      # 0x1ffa1
jmp 0x191ca
leaq 0x6de9(%rip), %rdi      # 0x1ffb3
xorl %eax, %eax
jmp 0x106a9
leaq 0x6ddb(%rip), %rdi      # 0x1ffb3
xorl %eax, %eax
jmp 0x106a9
pushq %rax
leaq 0x2fb4(%rip), %rdi      # 0x1c19b
leaq 0x6dcf(%rip), %rsi      # 0x1ffbd
leaq 0x6dd5(%rip), %rcx      # 0x1ffca
movl $0x122, %edx            # imm = 0x122
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defstring
void defstring(int len, char *s) {
    if (graph_output) return;
    while (len > 0) {
        print("\tDB($%x)\n",(unsigned char)*s++);
        len--;
    }
}

// Assembly:
testl %edi, %edi
jle 0x19239
testb $0x1, 0x1923e(%rip)     # 0x32448
jne 0x19239
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
incl %ebp
leaq 0x6d79(%rip), %r14      # 0x1ff97
movzbl (%rbx), %esi
incq %rbx
movq %r14, %rdi
xorl %eax, %eax
callq 0x106a9
decl %ebp
cmpl $0x1, %ebp
ja 0x1921e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: allocreg
int allocreg(Symbol p) {
    if (nbregs==8 || p->type->size==5) return 0;
    p->x.name=regname[nbregs];
    p->x.adrmode='R';
    nbregs++;
    return 1;
}

// Assembly:
movslq 0x1941a(%rip), %rcx     # 0x32690
xorl %eax, %eax
cmpq $0x8, %rcx
je 0x192a6
movq 0x20(%rdi), %rdx
cmpl $0x5, 0x8(%rdx)
je 0x192a6
leaq 0x191c1(%rip), %rax     # 0x32450
movq (%rax,%rcx,8), %rax
movq %rax, (%rdi)
movb $0x52, 0x8(%rdi)
leal 0x1(%rcx), %eax
movl %eax, 0x193ed(%rip)     # 0x32690
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: local
void local(Symbol p) {
    if (optimizelevel>1 && p->sclass==REGISTER && allocreg(p))
        return; /* allocreg ok */
    if (p->x.name && p->x.name[0]!='*') return; /* keep previous local (it isn't busy) */
    p->x.name = stringf(graph_output?"local(%d)":"(fp),%d",offset);
    p->x.adrmode = 'A';
    p->sclass = AUTO;
    offset+=p->type->size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0x102a5(%rip)     # 0x297c8
jl 0x19537
cmpb $0x4e, 0x1a(%rbx)
jne 0x19537
movq %rbx, %rdi
callq 0x1926f
testl %eax, %eax
jne 0x19582
movq (%rbx), %rax
testq %rax, %rax
je 0x19544
cmpb $0x2a, (%rax)
jne 0x19582
leaq 0x6b08(%rip), %rax      # 0x20053
cmpb $0x0, 0x18ef6(%rip)     # 0x32448
leaq 0x6b04(%rip), %rdi      # 0x2005d
cmovneq %rax, %rdi
movl 0x19131(%rip), %esi     # 0x32694
xorl %eax, %eax
callq 0x10a97
movq %rax, (%rbx)
movb $0x41, 0x8(%rbx)
movb $0x43, 0x1a(%rbx)
movq 0x20(%rbx), %rax
movl 0x8(%rax), %eax
addl %eax, 0x19112(%rip)     # 0x32694
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: linearize
static Node *linearize(Node p, Node *last, Node next) {
    if (p && !p->x.visited) {
        if ( optimizelevel>0 ) {
            switch (generic(p->op)) {
            case CNST:
            case ADDRG: case ADDRL: case ADDRF:
                p->x.optimized=1;
                p->x.result=p->syms[0];
                p->x.adrmode=p->syms[0]->x.adrmode;
                p->x.name=p->syms[0]->x.name;
                return last;
            }
        }
        last = linearize(p->kids[0], last, NULL);
        last = linearize(p->kids[1], last, NULL);
        p->x.visited = 1;
        *last = p;
        last = &p->x.next;
    }
    *last = next;
    return last;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19b81
movq %rdi, %rbx
cmpb $0x0, 0x61(%rdi)
jne 0x19b81
cmpl $0x0, 0xfcac(%rip)      # 0x297c8
jle 0x19b5e
movl (%rbx), %eax
andl $-0x10, %eax
leal -0x100(%rax), %ecx
cmpl $0x20, %ecx
ja 0x19b3e
movabsq $0x100010001, %rdx      # imm = 0x100010001
btq %rcx, %rdx
jb 0x19b43
cmpl $0x10, %eax
jne 0x19b5e
movb $0x1, 0x60(%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x48(%rbx)
movb 0x8(%rax), %cl
movb %cl, 0x40(%rbx)
movq (%rax), %rax
movq %rax, 0x38(%rbx)
jmp 0x19b85
movq 0x20(%rbx), %rdi
callq 0x19b06
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x19b06
movb $0x1, 0x61(%rbx)
movq %rbx, (%rax)
addq $0x58, %rbx
movq %rbx, %rsi
andq $0x0, (%rsi)
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: asmcode
void asmcode(char *str, Symbol argv[]) {
    for ( ; *str; str++)
        if (*str == '%' && str[1] >= 0 && str[1] <= 9)
            print("%s", argv[(int)*++str]->x.name);
        else
            print("%c", *str);
    print("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5d77(%rip), %r15      # 0x1f916
leaq 0x5345(%rip), %r12      # 0x1eeeb
movzbl (%r14), %eax
cmpl $0x25, %eax
je 0x19bb5
testl %eax, %eax
jne 0x19bd6
jmp 0x19be8
movzbl 0x1(%r14), %ecx
cmpq $0x9, %rcx
ja 0x19bd6
incq %r14
movq (%rbx,%rcx,8), %rax
movq (%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x106a9
jmp 0x19be3
movsbl %al, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x106a9
incq %r14
jmp 0x19ba6
leaq 0x3fa5(%rip), %rdi      # 0x1db94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x106a9