LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: definelab
void definelab(int lab) {
	Code cp;

	walk(0, 0, 0);
	code(Label);
	codelist->u.node = newnode(LABEL+V, 0, 0, findlabel(lab));
	for (cp = codelist; cp->kind <= Label; )
		cp = cp->prev;
	while (cp->kind == Jump && cp->u.node && cp->u.node->kids[0]
	&& cp->u.node->kids[0]->op == ADDRG+P
	&& cp->u.node->kids[0]->syms[0]->u.l.label == lab) {
		cp->u.node->kids[0]->syms[0]->ref--;
		assert(cp->next);
		cp->prev->next = cp->next;
		cp->next->prev = cp->prev;
		cp = cp->prev;
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3941
movl $0x5, %edi
callq 0x3468
movl %ebx, %edi
callq 0x17383
movl $0x258, %edi            # imm = 0x258
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4e40
leaq 0x13191(%rip), %rcx     # 0x28138
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
cmpl $0x5, (%rcx)
ja 0x15001
movq 0x8(%rcx), %rcx
cmpl $0x6, (%rcx)
jb 0x14fb3
jmp 0x15001
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x15006
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x15006
cmpl $0x107, (%rax)          # imm = 0x107
jne 0x15006
movq 0x8(%rax), %rax
cmpl %ebx, 0x48(%rax)
jne 0x15006
decl 0x1c(%rax)
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x15008
movq 0x8(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rcx
cmpl $0x9, (%rcx)
je 0x14fbe
popq %rbx
retq
leaq 0xb495(%rip), %rdi      # 0x204a4
leaq 0xb497(%rip), %rsi      # 0x204ad
leaq 0xb49e(%rip), %rcx      # 0x204bb
movl $0x74, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: definept
Code definept(p) Coordinate *p; {
	int n;
	Code cp = code(Defpoint);

	cp->u.point.src = p ? *p : src;
	cp->u.point.point = npoints;
	if (ncalled > 0 && (n = findcount(src.file, src.x, src.y)) >= 0)
		refinc = 1000*n/ncalled + 1;
	if (events.points) {
		Tree e = 0;
		apply(events.points, (Generic)&cp->u.point.src, (Generic)&e);
		if (e)
			listnodes(e, 0, 0);
	}
	if (glevel > 2)
		locus(identifiers, &cp->u.point.src);
	return cp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movl $0x4, %edi
callq 0x3468
movq %rax, %rbx
movq %rax, %r14
addq $0x18, %r14
testq %r15, %r15
je 0x15052
movups (%r15), %xmm0
jmp 0x1505c
leaq 0x168df(%rip), %rax     # 0x2b938
movups (%rax), %xmm0
movups %xmm0, (%r14)
leaq 0x16a11(%rip), %rax     # 0x2ba78
movl (%rax), %eax
movl %eax, 0x28(%rbx)
leaq 0x1358d(%rip), %r15     # 0x28600
cmpl $0x0, (%r15)
jle 0x150a6
leaq 0x168b8(%rip), %rax     # 0x2b938
movq (%rax), %rdi
movzwl 0x8(%rax), %esi
movzwl 0xa(%rax), %edx
callq 0x11d78
testl %eax, %eax
js 0x150a6
imull $0x3e8, %eax, %eax      # imm = 0x3E8
cltd
idivl (%r15)
incl %eax
movl %eax, 0x135de(%rip)     # 0x28684
leaq 0x16953(%rip), %rax     # 0x2ba00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x150de
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rsi
movq %r15, %rdx
callq 0x102f8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x150de
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a2a
leaq 0x1694b(%rip), %rax     # 0x2ba30
cmpl $0x3, (%rax)
jl 0x150fc
leaq 0x141f7(%rip), %rax     # 0x292e8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1775f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: equatelab
void equatelab(new, old) Symbol new, old; {
	struct equate *e = (struct equate *) talloc(sizeof *e);

	e->new = new;
	e->old = old;
	e->oldlink = 0;
	e->link = equlist;
	equlist = e;
	for (e = e->link; e; e = e->link)
		if (e->old == new)
			e->oldlink = equlist;
		else if (e->new == old)
			equlist->oldlink = e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1465e(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x15137
movq %rdx, 0x8(%rcx)
jmp 0x15148
leaq 0x1463a(%rip), %rsi     # 0x29778
movl $0x20, %edi
callq 0x17978
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq 0x17ba2(%rip), %rcx     # 0x2cd00
movq %rcx, 0x18(%rax)
movq %rax, 0x17b97(%rip)     # 0x2cd00
testq %rcx, %rcx
je 0x15189
cmpq %r14, 0x8(%rcx)
je 0x1517f
cmpq %rbx, (%rcx)
jne 0x15183
movq %rcx, 0x10(%rax)
jmp 0x15183
movq %rax, 0x10(%rcx)
movq 0x18(%rcx), %rcx
jmp 0x15169
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: visit
static void visit(p) struct equate *p; {
	if (p && p->old) {
		visit(p->oldlink);
		p->new->u.l.equatedto = p->old->u.l.equatedto;
		p->old = 0;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x151e6
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x151e5
movq 0x10(%rbx), %rdi
callq 0x151b5
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x50(%rcx), %rcx
movq %rcx, 0x50(%rax)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: localaddr
static Symbol localaddr(p) Tree p; {
	if (p == 0)
		return 0;
	switch (generic(p->op)) {
	case INDIR: case CALL: case ARG:
		return 0;
	case ADDRL: case ADDRF:
		return p->u.sym;
	case RIGHT: case ASGN:
		if (p->kids[1])
			return localaddr(p->kids[1]);
		return localaddr(p->kids[0]);
	case COND: {
		Symbol q;
		if (p->kids[1] && (q = localaddr(p->kids[1])))
			return q;
		return localaddr(p->kids[2]);
		}
	default: {
		Symbol q;
		if (p->kids[0] && (q = localaddr(p->kids[0])))
			return q;
		return localaddr(p->kids[1]);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x15549
movq %rdi, %r14
movl (%rdi), %eax
andl $-0x10, %eax
cmpl $0x11f, %eax            # imm = 0x11F
jle 0x154d8
cmpl $0x290, %eax            # imm = 0x290
je 0x154f1
cmpl $0x2a0, %eax            # imm = 0x2A0
je 0x154e2
cmpl $0x120, %eax            # imm = 0x120
jne 0x15524
jmp 0x15540
cmpl $0x3f, %eax
jg 0x1550a
cmpl $0x30, %eax
jne 0x1551f
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x154a9
movq 0x10(%r14), %rdi
jmp 0x154a9
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x15504
callq 0x154a3
testq %rax, %rax
jne 0x15546
movq 0x20(%r14), %rdi
jmp 0x154a9
cmpl $0x40, %eax
je 0x15549
cmpl $0xd0, %eax
je 0x15549
cmpl $0x110, %eax            # imm = 0x110
jne 0x15524
jmp 0x15540
cmpl $0x20, %eax
je 0x15549
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x15537
callq 0x154a3
testq %rax, %rax
jne 0x15546
movq 0x18(%r14), %rdi
jmp 0x154a9
movq 0x28(%r14), %rbx
jmp 0x15549
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/stmt.c
// Function: branch
static void branch(int lab) {
	Code cp;

	walk(0, 0, 0);
	for (cp = codelist; cp->kind < Label; )
		cp = cp->prev;
	if (lab)
		while (cp->kind == Label && islabel(cp->u.node)
		&& cp->u.node->syms[0]->u.l.label != lab) {
			Symbol old = findlabel(lab);
			equatelab(cp->u.node->syms[0], old);
			old->ref++;
			cp->prev->next = cp->next;
			if (cp->next)
				cp->next->prev = cp->prev;
			else
				codelist = cp->prev;
			do
				cp = cp->prev;
			while (cp->kind < Label);
		}
	if (cp->kind != Jump) {
		code(Jump);
		codelist->u.node = lab ? jump(lab) : 0;
	}
	/* else do nothing and thus delete dead branch */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3941
leaq 0x12bc8(%rip), %rax     # 0x28138
movq (%rax), %r15
leaq 0x8(%r15), %rax
cmpl $0x5, (%r15)
jb 0x15570
testl %ebx, %ebx
je 0x155fc
cmpl $0x5, (%r15)
jne 0x155fc
leaq 0x12baa(%rip), %r12     # 0x28138
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x155fc
cmpl $0x258, (%rax)          # imm = 0x258
jne 0x155fc
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x155fc
cmpl %ebx, 0x48(%rax)
je 0x155fc
movl %ebx, %edi
callq 0x17383
movq %rax, %r14
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x15109
incl 0x1c(%r14)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r15), %rcx
testq %rcx, %rcx
jne 0x155e5
movq %r12, %rcx
jmp 0x155e9
addq $0x8, %rcx
movq %rax, (%rcx)
movq 0x8(%r15), %r15
cmpl $0x5, (%r15)
jb 0x155ec
cmpl $0x5, (%r15)
je 0x1558e
cmpl $0x9, (%r15)
je 0x15629
movl $0x9, %edi
callq 0x3468
testl %ebx, %ebx
je 0x15619
movl %ebx, %edi
callq 0x4d7e
jmp 0x1561b
xorl %eax, %eax
leaq 0x12b16(%rip), %rcx     # 0x28138
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: append
List append(x, list) Generic x; List list; {
	List new = freenodes;

	if (new)
		freenodes = freenodes->link;
	else
		new = (List)alloc(sizeof *new);
	if (list) {
		new->link = list->link;
		list->link = new;
	} else
		new->link = new;
	new->x = x;
	return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x16213(%rip), %rax     # 0x2cd10
testq %rax, %rax
je 0x16b0f
movq 0x8(%rax), %rcx
movq %rcx, 0x16203(%rip)     # 0x2cd10
jmp 0x16b44
leaq 0x12c5a(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x16b33
movq %rdx, 0x8(%rcx)
jmp 0x16b44
leaq 0x12c36(%rip), %rsi     # 0x29770
movl $0x10, %edi
callq 0x17978
testq %r14, %r14
je 0x16b57
movq 0x8(%r14), %rcx
addq $0x8, %r14
movq %rcx, 0x8(%rax)
jmp 0x16b5b
leaq 0x8(%rax), %r14
movq %rax, (%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: length
int length(list) List list; {
	int n = 0;

	if (list) {
		List lp = list;
		do n++;
		while ((lp = lp->link) != list);
	}
	return n;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x16b7e
movq %rdi, %rcx
incl %eax
movq 0x8(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x16b73
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/string.c
// Function: stringd
char *stringd(int n) {
	char str[30], *s = &str[30];
	unsigned m;

	if (n >= 0 && n < sizeof nums/sizeof nums[0])
		return nums[n];
	if (n == INT_MIN)
		m = (unsigned)INT_MAX + 1;
	else if (n < 0)
		m = -n;
	else
		m = n;
	do
		*--s = m%10 + '0';
	while (m /= 10);
	if (n < 0)
		*--s = '-';
	return stringn(s, &str[30] - s);
}

// Assembly:
movl %edi, %eax
cmpl $0x63, %edi
ja 0x16e44
movl %eax, %eax
leaq 0x10b11(%rip), %rcx     # 0x27950
movq (%rcx,%rax,8), %rax
retq
subq $0x28, %rsp
leaq 0x1e(%rsp), %rsi
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
movl $0x80000000, %ecx       # imm = 0x80000000
cmovnol %edx, %ecx
leaq 0x1d(%rsp), %rdi
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ecx, %r8d
imulq %rdx, %r8
shrq $0x23, %r8
leal (%r8,%r8), %r9d
leal (%r9,%r9,4), %r9d
movl %ecx, %r10d
subl %r9d, %r10d
orb $0x30, %r10b
movb %r10b, (%rdi)
decq %rdi
cmpl $0x9, %ecx
movl %r8d, %ecx
ja 0x16e66
testl %eax, %eax
js 0x16e9a
incq %rdi
jmp 0x16e9d
movb $0x2d, (%rdi)
subl %edi, %esi
callq 0x16c24
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: exitscope
void exitscope() {
	rmtypes();
	rmtemps(0, level);
	if (identifiers->level == level) {
		if (Aflag >= 2) {
			int n = 0;
			Symbol p;
			for (p = identifiers->list; p && p->scope == level; p = p->up)
				if (++n > 127) {
					warning("more than 127 identifiers declared in a block\n");
					break;
				}
		}
		if (xref)	/* (omit) */
			setuses(identifiers);	/* (omit) */
		identifiers = identifiers->previous;
	}
	if (types->level == level) {
		if (xref) {	/* (omit) */
			foreach(types, level, fielduses, (Generic)0);	/* (omit) */
			setuses(types);	/* (omit) */
		}	/* (omit) */
		types = types->previous;
	}
	assert(level >= GLOBAL);
	--level;
}

// Assembly:
pushq %rax
callq 0x1a35d
movl 0x17c61(%rip), %eax     # 0x2ed30
movq 0x17c7a(%rip), %rcx     # 0x2ed50
testq %rcx, %rcx
je 0x1710b
leaq 0x17c6e(%rip), %rdx     # 0x2ed50
movq (%rcx), %rsi
movzwl 0x18(%rsi), %edi
cmpl %edi, %eax
je 0x170fc
cmpb $0x0, 0x1a(%rsi)
je 0x170fc
addq $0x8, %rcx
movq %rcx, %rdx
jmp 0x17103
movq 0x8(%rcx), %rcx
movq %rcx, (%rdx)
movq (%rdx), %rcx
testq %rcx, %rcx
jne 0x170e2
movq 0x121d6(%rip), %rcx     # 0x292e8
cmpl %eax, (%rcx)
jne 0x1717f
leaq 0x1493b(%rip), %rdx     # 0x2ba58
cmpl $0x2, (%rdx)
jl 0x17155
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x17155
movl $0x80, %edx
movzwl 0x18(%rcx), %esi
cmpl %esi, %eax
jne 0x17155
decl %edx
je 0x17147
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
jne 0x17130
jmp 0x17155
leaq 0x99c8(%rip), %rdi      # 0x20b16
xorl %eax, %eax
callq 0x9be3
leaq 0x148d8(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x1716d
movq 0x12180(%rip), %rdi     # 0x292e8
callq 0x1723d
movq 0x12174(%rip), %rax     # 0x292e8
movq 0x8(%rax), %rax
movq %rax, 0x12169(%rip)     # 0x292e8
movq 0x1258a(%rip), %rdi     # 0x29710
movl 0x17ba4(%rip), %esi     # 0x2ed30
cmpl %esi, (%rdi)
jne 0x171c8
leaq 0x1489d(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x171b6
leaq 0x1a8(%rip), %rdx       # 0x1734b
xorl %ecx, %ecx
callq 0x172b1
movq 0x1255f(%rip), %rdi     # 0x29710
callq 0x1723d
movq 0x12553(%rip), %rax     # 0x29710
movq 0x8(%rax), %rax
movq %rax, 0x12548(%rip)     # 0x29710
movl 0x17b62(%rip), %eax     # 0x2ed30
cmpl $0x2, %eax
jle 0x171dd
decl %eax
movl %eax, 0x17b55(%rip)     # 0x2ed30
popq %rax
retq
leaq 0x9961(%rip), %rdi      # 0x20b45
leaq 0x98e5(%rip), %rsi      # 0x20ad0
leaq 0x9963(%rip), %rcx      # 0x20b55
movl $0x68, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: rmtemps
void rmtemps(int sclass, int level) {
	struct temporary *p, **q = &temps;

	for (p = *q; p; p = *q)
		if (p->sym->scope == level || p->sym->sclass == sclass)
			*q = p->link;
		else
			q = &p->link;
}

// Assembly:
movq 0x17b4d(%rip), %rax     # 0x2ed50
testq %rax, %rax
je 0x1723c
leaq 0x17b41(%rip), %rcx     # 0x2ed50
movq (%rax), %rdx
movzwl 0x18(%rdx), %r8d
cmpl %esi, %r8d
je 0x17224
movzbl 0x1a(%rdx), %edx
cmpl %edi, %edx
jne 0x1722d
movq 0x8(%rax), %rax
movq %rax, (%rcx)
jmp 0x17234
addq $0x8, %rax
movq %rax, %rcx
movq (%rcx), %rax
testq %rax, %rax
jne 0x1720f
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: setuses
void setuses(tp) Table tp; {
	if (xref) {
		int i;
		struct entry *p;
		for (i = 0; i < HASHSIZE; i++)
			for (p = tp->buckets[i]; p; p = p->link) {
				if (p->refs)
					p->sym.uses = (Coordinate **)list_to_a(p->refs, 0);
				p->refs = 0;
				symbols = append((Generic)&p->sym, symbols);
			}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x147eb(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x172ab
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x18(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x1729f
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x17275
xorl %esi, %esi
callq 0x16b7f
movq %rax, 0x38(%r14)
movq $0x0, 0x88(%r14)
movq 0x17ad1(%rip), %rsi     # 0x2ed58
movq %r14, %rdi
callq 0x16aec
movq %rax, 0x17ac2(%rip)     # 0x2ed58
movq 0x90(%r14), %r14
jmp 0x17259
incq %r15
cmpq $0x80, %r15
jne 0x17254
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: foreach
void foreach(tp, lev, apply, cl)
Table tp;
int lev;
dclproto(void (*apply),(Symbol, Generic));
Generic cl;
{
	assert(tp);
	while (tp && tp->level > lev)
		tp = tp->previous;
	if (tp && tp->level == lev) {
		Symbol p;
		Coordinate sav;
		sav = src;
		for (p = tp->list; p && p->scope == lev; p = p->up) {
			src = p->src;
			(*apply)(p, cl);
		}
		src = sav;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1732c
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl %ebp, (%rdi)
jle 0x172d9
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x172ca
jmp 0x1731f
jne 0x1731f
leaq 0x14656(%rip), %r12     # 0x2b938
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x17316
movzwl 0x18(%r15), %eax
cmpl %ebp, %eax
jne 0x17316
movups 0x28(%r15), %xmm0
movups %xmm0, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
movq 0x40(%r15), %r15
jmp 0x172ef
movaps (%rsp), %xmm0
movups %xmm0, (%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9833(%rip), %rdi      # 0x20b66
leaq 0x9796(%rip), %rsi      # 0x20ad0
leaq 0x983a(%rip), %rcx      # 0x20b7b
movl $0x96, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: findlabel
Symbol findlabel(int lab) {
	char *label = stringd(lab);
	Symbol p = lookup(label, labels[1]);
	if (p) return p;
	p = install(label, &labels[1], 0);
	p->generated = 1;
	p->u.l.label = lab;
	p->u.l.equatedto = p;
	defsymbol(p);
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x16e2f
movq %rax, %r15
movq 0x179af(%rip), %rsi     # 0x2ed48
movq %rax, %rdi
callq 0x173d9
movq %rax, %r14
testq %rax, %rax
jne 0x173d0
leaq 0x17998(%rip), %rsi     # 0x2ed48
movq %r15, %rdi
xorl %edx, %edx
callq 0x17429
movq %rax, %r14
orb $0x4, 0x1b(%rax)
movl %ebx, 0x48(%rax)
movq %rax, 0x50(%rax)
movq %rax, %rdi
callq 0x1a687
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: lookup
Symbol lookup(name, tp) char *name; Table tp; {
	struct entry *p;
	unsigned h = (unsigned)name&(HASHSIZE-1);

	assert(tp);
	do
		for (p = tp->buckets[h]; p; p = p->link)
			if (name == p->sym.name)
				return &p->sym;
	while ((tp = tp->previous));
	return 0;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1740a
movl %edi, %ecx
andl $0x7f, %ecx
movq 0x18(%rsi,%rcx,8), %rax
testq %rax, %rax
je 0x173fd
cmpq %rdi, 0x10(%rax)
je 0x17408
movq 0x90(%rax), %rax
jmp 0x173e9
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x173e4
xorl %eax, %eax
popq %rcx
retq
leaq 0x9755(%rip), %rdi      # 0x20b66
leaq 0x96b8(%rip), %rsi      # 0x20ad0
leaq 0x976b(%rip), %rcx      # 0x20b8a
movl $0xeb, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: install
Symbol install(char *name, Table *tpp, int perm) {
	struct entry *p;
	unsigned h = (unsigned)name&(HASHSIZE-1);

	if ((tpp == &identifiers || tpp == &types) && (*tpp)->level < level)
		*tpp = table(*tpp, level);
	if (perm)
		p = (struct entry *) alloc(sizeof *p);
	else
		p = (struct entry *) talloc(sizeof *p);
	BZERO(&p->sym, struct symbol);
	p->sym.name = name;
	p->sym.scope = (*tpp)->level;
	p->sym.up = (*tpp)->list;
	(*tpp)->list = &p->sym;
	p->link = (*tpp)->buckets[h];
	(*tpp)->buckets[h] = p;
	p->refs = 0;	/* (omit) */
	return &p->sym;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x11eac(%rip), %rax     # 0x292e8
cmpq %rax, %rsi
setne %al
leaq 0x122c7(%rip), %rcx     # 0x29710
cmpq %rcx, %rsi
setne %cl
testb %cl, %al
jne 0x17468
movq (%rbx), %rdi
movl 0x178d4(%rip), %esi     # 0x2ed30
cmpl %esi, (%rdi)
jge 0x17468
callq 0x176a9
movq %rax, (%rbx)
testl %ebp, %ebp
je 0x17496
leaq 0x122fd(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x98, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x98(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jb 0x174b7
leaq 0x122dc(%rip), %rsi     # 0x29770
jmp 0x174c4
leaq 0x122db(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x98, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x98(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x174bd
movq %rdx, 0x8(%rcx)
jmp 0x174ce
leaq 0x122b4(%rip), %rsi     # 0x29778
movl $0x98, %edi
callq 0x17978
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl %r14d, %ecx
andl $0x7f, %ecx
xorl %edx, %edx
movq %rdx, 0x80(%rax)
movq %r14, 0x10(%rax)
movq (%rbx), %rsi
movzwl (%rsi), %edi
movw %di, 0x18(%rax)
movq 0x10(%rsi), %rsi
movq %rsi, 0x40(%rax)
movq (%rbx), %rsi
movq %rax, 0x10(%rsi)
movq (%rbx), %rsi
shll $0x3, %ecx
movq 0x18(%rsi,%rcx), %rsi
movq %rsi, 0x90(%rax)
movq (%rbx), %rsi
movq %rax, 0x18(%rsi,%rcx)
movq %rdx, 0x88(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: findtype
Symbol findtype(ty) Type ty; {
	Table tp = identifiers;
	int i;
	struct entry *p;

	assert(tp);
	do
		for (i = 0; i < HASHSIZE; i++)
			for (p = tp->buckets[i]; p; p = p->link)
				if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
					return &p->sym;
	while ((tp = tp->previous));
	return 0;
}

// Assembly:
pushq %rax
movq 0x11d9e(%rip), %rcx     # 0x292e8
testq %rcx, %rcx
je 0x17589
xorl %edx, %edx
movq 0x18(%rcx,%rdx,8), %rax
testq %rax, %rax
je 0x17570
cmpq %rdi, 0x20(%rax)
jne 0x17567
cmpb $0x53, 0x1a(%rax)
je 0x17587
movq 0x90(%rax), %rax
jmp 0x17556
incq %rdx
cmpq $0x80, %rdx
jne 0x17551
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x1754f
xorl %eax, %eax
popq %rcx
retq
leaq 0x95d6(%rip), %rdi      # 0x20b66
leaq 0x9539(%rip), %rsi      # 0x20ad0
leaq 0x95cb(%rip), %rcx      # 0x20b69
movl $0x85, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: genident
Symbol genident(int sclass, Type ty, int lev) {
	Symbol p;

	if (lev <= PARAM)
		p = (Symbol) alloc(sizeof *p);
	else
		p = (Symbol) talloc(sizeof *p);
	BZERO(p, struct symbol);
	p->name = stringd(genlabel(1));
	p->scope = lev;
	p->sclass = sclass;
	p->type = ty;
	p->generated = 1;
	if (lev < PARAM)
		defsymbol(p);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
cmpl $0x4, %edx
jg 0x175e5
leaq 0x121ae(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jb 0x17606
leaq 0x1218d(%rip), %rsi     # 0x29770
jmp 0x17613
leaq 0x1218c(%rip), %rax     # 0x29778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x1760c
movq %rcx, 0x8(%rax)
jmp 0x17620
leaq 0x12165(%rip), %rsi     # 0x29778
movl $0x88, %edi
callq 0x17978
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r15)
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq $0x0, 0x80(%r15)
movl 0x120bd(%rip), %edi     # 0x29718
leal 0x1(%rdi), %eax
movl %eax, 0x120b4(%rip)     # 0x29718
callq 0x16e2f
movq %rax, 0x10(%r15)
movw %bx, 0x18(%r15)
movb %bpl, 0x1a(%r15)
movq %r14, 0x20(%r15)
orb $0x4, 0x1b(%r15)
cmpl $0x3, %ebx
jg 0x1768c
movq %r15, %rdi
callq 0x1a687
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: table
Table table(Table tp, int lev) {
	int i;
	Table new = (Table)talloc(sizeof *new);

	assert(lev > GLOBAL || lev == LABELS);
	new->previous = tp;
	new->level = lev;
	new->list = tp ? tp->list : 0;	/* (omit) */
	for (i = 0; i < HASHSIZE; i++)
		new->buckets[i] = 0;
	return new;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x120bf(%rip), %rax     # 0x29778
movq (%rax), %rax
movl $0x418, (%rax)          # imm = 0x418
movq 0x8(%rax), %rbx
leaq 0x418(%rbx), %rcx
cmpq 0x10(%rax), %rcx
jae 0x176d9
movq %rcx, 0x8(%rax)
jmp 0x176ed
leaq 0x12098(%rip), %rsi     # 0x29778
movl $0x418, %edi            # imm = 0x418
callq 0x17978
movq %rax, %rbx
cmpl $0x4, %ebp
setge %al
cmpl $0x2, %ebp
sete %cl
orb %al, %cl
je 0x1772c
movq %r14, 0x8(%rbx)
movl %ebp, (%rbx)
testq %r14, %r14
je 0x1770e
movq 0x10(%r14), %rax
jmp 0x17710
xorl %eax, %eax
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x30e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x94c6(%rip), %rdi      # 0x20bf9
leaq 0x9396(%rip), %rsi      # 0x20ad0
leaq 0x94d6(%rip), %rcx      # 0x20c17
movl $0x137, %edx            # imm = 0x137
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: newconst
Symbol newconst(Value v, int tc) {
	static Type *btot[] = { 0, &floattype, &doubletype, &chartype,
		&shorttype, &inttype, &unsignedtype, &voidptype };

	assert(tc > 0 && tc < sizeof btot/sizeof btot[0]);
	return constant(*btot[tc], v);
}

// Assembly:
leal -0x1(%rsi), %ecx
cmpl $0x7, %ecx
jae 0x177bf
movq %rdi, %rax
movl %esi, %ecx
leaq 0x104c0(%rip), %rdx     # 0x27c70
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rdi
movq %rax, %rsi
jmp 0x16eac
pushq %rax
leaq 0x93d3(%rip), %rdi      # 0x20b9a
leaq 0x9302(%rip), %rsi      # 0x20ad0
leaq 0x93ef(%rip), %rcx      # 0x20bc4
movl $0xf9, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: newtemp
Symbol newtemp(int sclass, int tc) {
	Symbol t1;
	static Type *btot[] = { 0, &floattype, &doubletype, &chartype,
		&shorttype, &inttype, &unsignedtype, &voidptype };

	assert(tc > 0 && tc < sizeof btot/sizeof btot[0]);
	t1 = temporary(sclass, *btot[tc]);
	t1->scope = LOCAL;
	if (t1->defined == 0) {
		local(t1);
		t1->defined = 1;
	}
	return t1;
}

// Assembly:
pushq %rbx
leal -0x1(%rsi), %eax
cmpl $0x7, %eax
jae 0x1781d
movl %esi, %eax
leaq 0x1047f(%rip), %rcx     # 0x27c70
movq (%rcx,%rax,8), %rax
movq (%rax), %rsi
callq 0x1783c
movq %rax, %rbx
movw $0x5, 0x18(%rax)
testb $0x1, 0x1b(%rax)
jne 0x17818
movq %rbx, %rdi
callq 0x1ac84
orb $0x1, 0x1b(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x9376(%rip), %rdi      # 0x20b9a
leaq 0x92a5(%rip), %rsi      # 0x20ad0
leaq 0x93ae(%rip), %rcx      # 0x20be0
movl $0x103, %edx            # imm = 0x103
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: temporary
Symbol temporary(int sclass, Type ty) {
	Symbol t1;
	struct temporary *p, **q = &temps;

	for (p = *q; p; q = &p->link, p = *q)
		if (p->sym->sclass == sclass
		&& p->sym->type->size  == ty->size
		&& p->sym->type->align >= ty->align) {
			*q = p->link;
			p->sym->type = ty;
			return p->sym;
		}
	t1 = genident(sclass, ty, level);
	t1->temporary = 1;
	return t1;
}

// Assembly:
pushq %rax
movq 0x1750c(%rip), %rax     # 0x2ed50
testq %rax, %rax
je 0x17888
leaq 0x17500(%rip), %rcx     # 0x2ed50
movq (%rax), %rdx
movzbl 0x1a(%rdx), %r8d
cmpl %edi, %r8d
jne 0x17875
movq 0x20(%rdx), %rdx
movl 0x8(%rdx), %r8d
cmpl 0x8(%rsi), %r8d
jne 0x17875
movzwl 0x4(%rdx), %edx
cmpw 0x4(%rsi), %dx
jge 0x17899
movq %rax, %rcx
movq 0x8(%rax), %rdx
addq $0x8, %rcx
movq %rdx, %rax
testq %rdx, %rdx
jne 0x17850
movl 0x174a2(%rip), %edx     # 0x2ed30
callq 0x175a8
orb $0x2, 0x1b(%rax)
popq %rcx
retq
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rax
movq %rsi, 0x20(%rax)
jmp 0x17897
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: release
void release(t1) Symbol t1; {
	if (t1->ref) {
		struct temporary *p = (struct temporary *) talloc(sizeof *p);
		p->sym = t1;
		p->link = temps;
		temps = p;
		t1->ref = 0;
	}
}

// Assembly:
cmpl $0x0, 0x1c(%rdi)
je 0x17905
pushq %rbx
movq %rdi, %rbx
leaq 0x11ebe(%rip), %rax     # 0x29778
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x178d7
movq %rdx, 0x8(%rcx)
jmp 0x178e8
leaq 0x11e9a(%rip), %rsi     # 0x29778
movl $0x10, %edi
callq 0x17978
movq %rbx, (%rax)
movq 0x1745e(%rip), %rcx     # 0x2ed50
movq %rcx, 0x8(%rax)
movq %rax, 0x17453(%rip)     # 0x2ed50
movl $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: use
void use(p, src) Symbol p; Coordinate src; {
	if (xref) {
		Coordinate *cp = (Coordinate *)alloc(sizeof *cp);
		*cp = src;
		((struct entry *)p)->refs = append((Generic)cp, ((struct entry *)p)->refs);
	}
}

// Assembly:
leaq 0x14127(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x17977
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x11e49(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x17944
movq %rcx, 0x8(%rax)
jmp 0x17958
leaq 0x11e25(%rip), %rsi     # 0x29770
movl $0x10, %edi
callq 0x17978
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq 0x88(%rbx), %rsi
callq 0x16aec
movq %rax, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: allocate
char *allocate(int n, Arena *p) {
	Arena ap = *p;

	while (ap->avail + n > ap->limit)
		if (ap->next) {		/* move to next arena */
			ap = ap->next;
			ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
		} else if (freearenas) {
		    ap->next = freearenas;
			freearenas = freearenas->next;
			ap = ap->next;
			ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
			ap->first = (*p)->first;
			ap->next = 0;
		} else {		/* allocate a new arena */
			int m = n + MEMINCR*1024 + roundup(sizeof *ap, sizeof (double));
			ap->next = (Arena) malloc(m);
			assert(ap->next);
			if ((char *)ap->next == ap->limit) /* extend previous arena? */
				ap->limit = (char *)ap->next + m;
			else {			/* link to a new arena */
				ap = ap->next;
				ap->limit = (char *)ap + m;
				ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
			}
			ap->first = (*p)->first;
			ap->next = 0;
		}
	*p = ap;
	ap->avail += n;
	return ap->avail - n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq (%rsi), %r13
movslq %edi, %r8
movq 0x8(%r13), %rax
addq %r8, %rax
movq 0x10(%r13), %r14
cmpq %r14, %rax
jbe 0x17a79
leaq 0x10(%r13), %rbp
movq 0x173c5(%rip), %r12     # 0x2ed70
addl $0x2828, %edi           # imm = 0x2828
movslq %edi, %rbx
movq %r8, (%rsp)
movq 0x20(%r13), %rcx
testq %rcx, %rcx
je 0x179d1
leaq 0x28(%rcx), %rax
movq %rax, 0x8(%rcx)
movq %r12, %rax
jmp 0x17a59
testq %r12, %r12
je 0x17a0a
movq %r12, 0x20(%r13)
movq 0x20(%r12), %rax
movq %rax, 0x1738a(%rip)     # 0x2ed70
leaq 0x28(%r12), %rcx
movq %rcx, 0x8(%r12)
movq (%r15), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%r12)
movq $0x0, 0x20(%r12)
movq %r12, %rcx
jmp 0x17a59
movq %rbx, %rdi
callq 0x3150
movq %rax, 0x20(%r13)
testq %rax, %rax
je 0x17a99
leaq (%rax,%rbx), %rcx
cmpq %r14, %rax
je 0x17a38
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
movq %rax, %r13
jmp 0x17a3c
movq %rcx, (%rbp)
movq (%rsp), %r8
movq (%r15), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%r13)
movq $0x0, 0x20(%r13)
movq %r12, %rax
movq %r13, %rcx
movq 0x8(%rcx), %rdx
addq %r8, %rdx
leaq 0x10(%rcx), %rbp
movq 0x10(%rcx), %r14
movq %rcx, %r13
movq %rax, %r12
cmpq %r14, %rdx
ja 0x179b8
jmp 0x17a7c
movq %r13, %rcx
movq %rcx, (%r15)
movq 0x8(%rcx), %rax
addq %rax, %r8
movq %r8, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x92ec(%rip), %rdi      # 0x20d8c
leaq 0x92ee(%rip), %rsi      # 0x20d95
leaq 0x92f5(%rip), %rcx      # 0x20da3
movl $0x21, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: deallocate
void deallocate(p) Arena *p; {
	Arena first = (*p)->first;

	(*p)->next = freearenas;
	freearenas = first->next;
	first->next = 0;
	*p = first;
}

// Assembly:
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movq 0x172aa(%rip), %rdx     # 0x2ed70
movq %rdx, 0x20(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x1729b(%rip)     # 0x2ed70
movq $0x0, 0x20(%rcx)
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: cvtconst
Tree cvtconst(p) Tree p; {
	Symbol q = constant(p->type, p->u.v);
	Tree e;

	if (q->u.c.loc == 0)
		q->u.c.loc = genident(STATIC, p->type, GLOBAL);
	if (isarray(p->type)) {
		e = tree(ADDRG+P, atop(p->type), 0, 0);
		e->u.sym = q->u.c.loc;
	} else
		e = idnode(q->u.c.loc);
	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x16eac
movq %rax, %rbx
cmpq $0x0, 0x50(%rax)
jne 0x17b16
movq 0x8(%r14), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x175a8
movq %rax, 0x50(%rbx)
movq 0x8(%r14), %rdi
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x17b26
movq 0x10(%rdi), %rax
cmpl $0xc, (%rax)
jne 0x17b51
callq 0x18b7d
movl $0x107, %edi            # imm = 0x107
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x17b61
movq 0x50(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9d77
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: tree
Tree tree(op, type, left, right) int op; Type type; Tree left, right; {
	register Tree p;

	if (ntree < sizeof trees/sizeof trees[0])
		p = &trees[ntree++];
	else
		p = (Tree)talloc(sizeof *p);
	p->op = op;
	p->type = type;
	p->kids[0] = left;
	p->kids[1] = right;
	p->node = 0;
	p->u.sym = 0;
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl 0x171ff(%rip), %eax     # 0x2ed78
cmpq $0x63, %rax
ja 0x17b9c
leal 0x1(%rax), %ecx
movl %ecx, 0x171f0(%rip)     # 0x2ed78
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x171e9(%rip), %rax     # 0x2ed80
addq %rcx, %rax
jmp 0x17bce
movq 0x11bd5(%rip), %rcx     # 0x29778
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x17bbd
movq %rdx, 0x8(%rcx)
jmp 0x17bce
leaq 0x11bb4(%rip), %rsi     # 0x29778
movl $0x30, %edi
callq 0x17978
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: hascall
int hascall(p) Tree p; {
	if (p == 0)
		return 0;
	if (generic(p->op) == CALL
#ifdef SPARC
	|| p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
	|| p->op == DIV+U || p->op == MOD+U || p->op == MUL+U
#endif
	)
		return 1;
	return hascall(p->kids[0]) || hascall(p->kids[1]);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
testq %rbx, %rbx
je 0x17c1d
movl (%rbx), %eax
andl $-0x10, %eax
cmpl $0xd0, %eax
je 0x17c1f
movq 0x10(%rbx), %rdi
callq 0x17bee
testl %eax, %eax
jne 0x17c1f
movq 0x18(%rbx), %rbx
jmp 0x17bf9
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: opname
char *opname(int op) {
	static char *opnames[] = {
	"",
#define NEEDNAMES
#include "ops.h"
	};
	char *name;

	switch (op) {
	case AND:  return "AND";
	case NOT:  return "NOT";
	case OR:   return "OR";
	case COND: return "COND";
	case RIGHT:return "RIGHT";
	case FIELD:return "FIELD";
	}
	if (opindex(op) > 0 && opindex(op) < sizeof opnames/sizeof opnames[0])
		name = opnames[opindex(op)];
	else
		name = stringd(opindex(op));
	if (optype(op) > 0 && optype(op) < sizeof (TYPENAMES) - 1)
		return stringf("%s%c", name, TYPENAMES[optype(op)]);
	else
		return stringf("%s+%d", name, optype(op));
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal -0x260(%rbx), %eax
roll $0x1c, %eax
cmpl $0x6, %eax
jae 0x17c4b
movl %eax, %eax
leaq 0x9132(%rip), %rcx      # 0x20d74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
popq %rbx
retq
movl %ebx, %edi
sarl $0x4, %edi
leal -0x1(%rdi), %eax
cmpl $0x24, %eax
ja 0x17c6a
movl %edi, %eax
leaq 0x907b(%rip), %rcx      # 0x20cdc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x17c72
callq 0x16e2f
movq %rax, %rsi
andl $0xf, %ebx
leal -0x1(%rbx), %eax
cmpl $0x8, %eax
ja 0x17c91
leaq 0x91ea(%rip), %rax      # 0x20e6e
movsbl (%rbx,%rax), %edx
leaq 0x91da(%rip), %rdi      # 0x20e69
jmp 0x17c9a
leaq 0x91e1(%rip), %rdi      # 0x20e79
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
jmp 0x11c7f
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/tree.c
// Function: retype
Tree retype(p, ty) Tree p; Type ty;{
	Tree q;

	if (p->type == ty)
		return p;
	q = tree(p->op, ty, p->kids[0], p->kids[1]);
	q->u = p->u;
	return q;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, 0x8(%rdi)
je 0x17cc6
movl (%rbx), %edi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
callq 0x17b61
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16e4f(%rip), %ebx     # 0x2ed78
movl $0x64, 0x16e45(%rip)    # 0x2ed78
movl %esi, %edi
callq *%rax
movl %ebx, 0x16e3b(%rip)     # 0x2ed78
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x117e7(%rip), %rcx     # 0x29780
movq %rcx, %rdx
shlq $0x4, %rdx
leaq 0x18099(%rip), %rsi     # 0x30040
movq %rdi, 0x8(%rdx,%rsi)
xorl %eax, %eax
leaq 0x180a3(%rip), %r8      # 0x30058
incl %eax
leaq 0x10(%r8), %r9
cmpq %rdi, (%r8)
movq %r9, %r8
jne 0x17fb5
cmpl %eax, %ecx
jne 0x17fd6
incl %ecx
movl %ecx, 0x117b1(%rip)     # 0x29780
movl $0x0, (%rdx,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1969f(%rip), %rsi     # 0x32040
testb %dl, %al
jne 0x189d3
movq (%rsi,%r13,8), %rax
testq %rax, %rax
je 0x189d3
cmpl %r12d, (%rax)
jne 0x189cd
cmpq %r15, 0x10(%rax)
jne 0x189cd
cmpl %r14d, 0x8(%rax)
jne 0x189cd
movswl 0x4(%rax), %ecx
cmpl %ebp, %ecx
jne 0x189cd
cmpq %rbx, 0x18(%rax)
je 0x18a35
movq 0x28(%rax), %rax
jmp 0x189a9
leaq 0x10d96(%rip), %rax     # 0x29770
movq (%rax), %rcx
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x189f7
movq %rdx, 0x8(%rcx)
jmp 0x18a0f
leaq 0x10d72(%rip), %rsi     # 0x29770
movl $0x30, %edi
callq 0x17978
leaq 0x19631(%rip), %rsi     # 0x32040
movl %r12d, (%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x8(%rax)
movw %bp, 0x4(%rax)
movq %rbx, 0x18(%rax)
movl $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_O1/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 0x8b1b(%rip), %r15      # 0x21592
testq %r14, %r14
je 0x18aa6
cmpl $0xf, (%r14)
movq %r14, %rax
jb 0x18a89
movq 0x10(%r14), %rax
cmpl $0xb, (%rax)
jne 0x18aa6
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x9720
movq 0x194f4(%rip), %r14     # 0x31f98
jmp 0x18a77
testl %ebx, %ebx
jne 0x18aaf
movswl 0x4(%r14), %ebx
leaq 0x1627a(%rip), %rax     # 0x2ed30
cmpl $0x4, (%rax)
jl 0x18ae2
cmpl $0xf, (%r14)
movq %r14, %rax
jb 0x18ac8
movq 0x10(%r14), %rax
cmpl $0xc, (%rax)
jne 0x18ae2
cmpl $0x0, 0x8(%r14)
jne 0x18ae2
leaq 0x8ad3(%rip), %rdi      # 0x215ae
xorl %eax, %eax
callq 0x9720
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x18b14
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
idivl %ecx
cmpl %ebp, %eax
jge 0x18b5a
leaq 0x8aef(%rip), %rdi      # 0x215ed
movq %r14, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
callq 0x9720
movl $0x1, %ebp
jmp 0x18b5a
cmpl $0xf, (%r14)
movq %r14, %rax
jb 0x18b21
movq 0x10(%r14), %rax
cmpq 0x194b8(%rip), %rax     # 0x31fe0
je 0x18b49
leaq 0x12f27(%rip), %rax     # 0x2ba58
cmpl $0x2, (%rax)
jl 0x18b5a
leaq 0x8a85(%rip), %rdi      # 0x215c2
movq %r14, %rsi
xorl %eax, %eax
callq 0x9be3
jmp 0x18b5a
leaq 0x8a42(%rip), %rdi      # 0x21592
movq %r14, %rsi
xorl %eax, %eax
callq 0x9720
imull 0x8(%r14), %ebp
movl $0xc, %edi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18963
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x18b8d
movq 0x10(%rbx), %rax
cmpl $0xc, (%rax)
jne 0x18ba4
movq 0x10(%rbx), %rsi
movq 0x1944b(%rip), %r8      # 0x31fe8
movl $0x7, %edi
jmp 0x18bc8
leaq 0x8a6a(%rip), %rdi      # 0x21615
leaq 0x8a73(%rip), %rsi      # 0x21625
xorl %eax, %eax
callq 0x9720
movq 0x19428(%rip), %r8      # 0x31fe8
movl $0x7, %edi
movq %rbx, %rsi
movl $0x2, %edx
movl $0x1, %ecx
popq %rbx
jmp 0x18963
// File: /workspace/github_c_makefile_star2_O1/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 0x18(%rdi), %rax
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x18c10
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0x18c07
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x18c18
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x18bee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %rax
movq 0x58(%rax), %rbp
testq %rbp, %rbp
je 0x18cf2
leaq 0x10b32(%rip), %r13     # 0x29778
movq (%rbp), %rsi
testq %rsi, %rsi
je 0x18ce5
testq %r14, %r14
je 0x18c69
movq %r14, %rax
cmpq %rsi, (%rax)
je 0x18c86
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x18c5b
testq %rsi, %rsi
je 0x18ce5
movq 0x18(%r15), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x18c9c
cmpq %rsi, (%rax)
je 0x18ce5
movq 0x18(%rax), %rax
jmp 0x18c76
leaq 0x8c18(%rip), %rdi      # 0x218a5
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x9720
jmp 0x18ce5
movq (%r13), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x18cba
movq %rdx, 0x8(%rcx)
jmp 0x18cc7
movl $0x20, %edi
movq %r13, %rsi
callq 0x17978
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl 0x10(%rbp), %ecx
addl %ebx, %ecx
movl %ecx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %r14
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0x18c46
movq 0x18(%r12), %rax
movq 0x58(%rax), %r12
testq %r12, %r12
je 0x18d28
cmpq $0x0, (%r12)
jne 0x18d21
movq 0x8(%r12), %rdi
movl 0x10(%r12), %ecx
addl %ebx, %ecx
movq %r15, %rsi
movq %r14, %rdx
callq 0x18c18
movq %rax, %r14
movq 0x18(%r12), %r12
jmp 0x18cfb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rdx
cmpl $0xf, %ecx
jb 0x19029
movq 0x10(%rbx), %rdx
cmpl $0xc, (%rdx)
jne 0x19051
movq 0x10(%rbx), %rsi
movl %eax, %edi
callq 0x19015
movl 0x8(%rbx), %edx
movswl 0x4(%rbx), %ecx
movl $0xc, %edi
movq %rax, %rsi
xorl %r8d, %r8d
popq %rbx
jmp 0x18963
movq %rbx, %rdx
cmpl $0xf, %ecx
jb 0x1905d
movq 0x10(%rbx), %rdx
cmpl $0xb, (%rdx)
jne 0x19075
leaq 0x878c(%rip), %rdi      # 0x217f5
xorl %eax, %eax
callq 0x9be3
jmp 0x19116
cmpl $0xf, %ecx
jne 0x19081
cmpl $0xf, %eax
jne 0x1908f
jmp 0x190b4
movl %ecx, %edx
xorl $0x1f, %edx
movl %eax, %esi
xorl $0xf, %esi
orl %edx, %esi
je 0x190b4
cmpl $0x10, %ecx
jne 0x190a6
cmpl $0x10, %eax
je 0x190b4
cmpl $0xf, %ecx
jb 0x190c9
addl %ecx, %eax
movq 0x10(%rbx), %rsi
jmp 0x190cc
movl %ecx, %edx
xorl $0x1f, %edx
movl %eax, %esi
xorl $0x10, %esi
orl %edx, %esi
jne 0x19099
leaq 0x875b(%rip), %rdi      # 0x21816
movl %eax, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9720
jmp 0x19116
movq %rbx, %rsi
xorl %ecx, %ecx
leaq 0x18f6b(%rip), %rdx     # 0x32040
movq (%rdx,%rcx,8), %rbx
testq %rbx, %rbx
je 0x190ee
cmpl %eax, (%rbx)
jne 0x190e8
cmpq %rsi, 0x10(%rbx)
je 0x19108
movq 0x28(%rbx), %rbx
jmp 0x190d9
incq %rcx
cmpq $0x80, %rcx
jne 0x190d5
movl 0x8(%rsi), %edx
movswl 0x4(%rsi), %ecx
movl %eax, %edi
jmp 0x19048
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
movzwl 0x4(%rsi), %eax
movw %ax, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq