LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: mul
static int mul(x, y, min, max, needconst) double x, y, min, max; int needconst; {
	int cond =
	   (x > -1 && x <= 1)
    || (y > -1 && y <= 1)
	|| (x < 0 && y < 0 && -x <= max/-y)
	|| (x < 0 && y > 0 &&  x >= min/y)
	|| (x > 0 && y < 0 &&  x >= min/y)
	|| (x > 0 && y > 0 &&  x <= max/y);
	if (!cond && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
pushq %rbx
ucomisd 0xb659(%rip), %xmm0     # 0x20280
movl $0x1, %ebx
jbe 0x14c40
movsd 0xb642(%rip), %xmm4     # 0x20278
ucomisd %xmm0, %xmm4
jae 0x14d01
ucomisd 0xb638(%rip), %xmm1     # 0x20280
jbe 0x14c5c
movsd 0xb626(%rip), %xmm4     # 0x20278
ucomisd %xmm1, %xmm4
jae 0x14d01
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x14c8e
ucomisd %xmm1, %xmm4
jbe 0x14c8e
movapd 0xb5bc(%rip), %xmm4     # 0x20230
movapd %xmm0, %xmm5
xorpd %xmm4, %xmm5
xorpd %xmm1, %xmm4
movapd %xmm3, %xmm6
divsd %xmm4, %xmm6
ucomisd %xmm5, %xmm6
jae 0x14d01
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x14ca8
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x14ca8
ucomisd %xmm4, %xmm1
ja 0x14d01
ucomisd %xmm2, %xmm0
jb 0x14cbe
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x14cbe
ucomisd %xmm1, %xmm2
ja 0x14d01
divsd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
setae %cl
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
cmpltpd %xmm0, %xmm3
cmpltpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb %cl, %al
testl %edi, %edi
sete %cl
orb %al, %cl
je 0x14cf3
movzbl %al, %ebx
jmp 0x14d01
leaq 0xb73e(%rip), %rdi      # 0x20438
xorl %eax, %eax
callq 0x9bfd
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x394a
movl $0x5, %edi
callq 0x3468
movl %ebx, %edi
callq 0x17238
movl $0x258, %edi            # imm = 0x258
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x4e71
leaq 0x142dd(%rip), %rcx     # 0x29138
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movl (%rcx), %eax
cmpl $0x5, %eax
ja 0x14e74
movq 0x8(%rcx), %rcx
movl (%rcx), %eax
cmpl $0x6, %eax
jb 0x14e69
cmpl $0x9, %eax
jne 0x14ec0
movq 0x18(%rcx), %rax
testq %rax, %rax
je 0x14ec0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x14ec0
cmpl $0x107, (%rax)          # imm = 0x107
jne 0x14ec0
movq 0x8(%rax), %rax
cmpl %ebx, 0x48(%rax)
jne 0x14ec0
decl 0x1c(%rax)
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x14ec2
movq 0x8(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq 0x10(%rcx), %rax
movq %rdx, 0x8(%rax)
cmpl $0x9, (%rdx)
movq %rdx, %rcx
je 0x14e79
popq %rbx
retq
leaq 0xb65b(%rip), %rdi      # 0x20524
leaq 0xb65d(%rip), %rsi      # 0x2052d
leaq 0xb664(%rip), %rcx      # 0x2053b
movl $0x74, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x14f0c
movups (%r15), %xmm0
jmp 0x14f16
leaq 0x17a25(%rip), %rax     # 0x2c938
movups (%rax), %xmm0
movups %xmm0, (%r14)
leaq 0x17b57(%rip), %rax     # 0x2ca78
movl (%rax), %eax
movl %eax, 0x28(%rbx)
leaq 0x146d3(%rip), %r15     # 0x29600
cmpl $0x0, (%r15)
jle 0x14f60
leaq 0x179fe(%rip), %rax     # 0x2c938
movq (%rax), %rdi
movzwl 0x8(%rax), %esi
movzwl 0xa(%rax), %edx
callq 0x11c2c
testl %eax, %eax
js 0x14f60
imull $0x3e8, %eax, %eax      # imm = 0x3E8
cltd
idivl (%r15)
incl %eax
movl %eax, 0x14724(%rip)     # 0x29684
leaq 0x17a99(%rip), %rax     # 0x2ca00
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x14f98
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r14, %rsi
movq %r15, %rdx
callq 0x1021b
movq (%r15), %rdi
testq %rdi, %rdi
je 0x14f98
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a33
leaq 0x17a91(%rip), %rax     # 0x2ca30
cmpl $0x3, (%rax)
jl 0x14fb6
leaq 0x1533d(%rip), %rax     # 0x2a2e8
movq (%rax), %rdi
movq %r14, %rsi
callq 0x175e7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x157a4(%rip), %rax     # 0x2a778
movq (%rax), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x14ff1
movq %rdx, 0x8(%rcx)
jmp 0x15002
leaq 0x15780(%rip), %rsi     # 0x2a778
movl $0x20, %edi
callq 0x17800
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq 0x18ce8(%rip), %rcx     # 0x2dd00
movq %rcx, 0x18(%rax)
movq %rax, 0x18cdd(%rip)     # 0x2dd00
testq %rcx, %rcx
je 0x15043
cmpq %r14, 0x8(%rcx)
je 0x15039
cmpq %rbx, (%rcx)
jne 0x1503d
movq %rcx, 0x10(%rax)
jmp 0x1503d
movq %rax, 0x10(%rcx)
movq 0x18(%rcx), %rcx
jmp 0x15023
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x150a0
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x1509f
movq 0x10(%rbx), %rdi
callq 0x1506f
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_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x153ec
movq %rdi, %r14
xorl %ebx, %ebx
movl (%r14), %eax
andl $-0x10, %eax
cmpl $0x11f, %eax            # imm = 0x11F
jle 0x15380
cmpl $0x290, %eax            # imm = 0x290
je 0x1539b
cmpl $0x2a0, %eax            # imm = 0x2A0
je 0x1538a
cmpl $0x120, %eax            # imm = 0x120
jne 0x153c1
jmp 0x153f0
cmpl $0x3f, %eax
jg 0x153a7
cmpl $0x30, %eax
jne 0x153bc
movq 0x18(%r14), %rax
testq %rax, %rax
jne 0x153de
movl $0x10, %r15d
jmp 0x153da
movq 0x18(%r14), %rdi
movl $0x20, %r15d
jmp 0x153cb
cmpl $0x40, %eax
je 0x153f9
cmpl $0xd0, %eax
je 0x153f9
cmpl $0x110, %eax            # imm = 0x110
jne 0x153c1
jmp 0x153f0
cmpl $0x20, %eax
je 0x153f9
movq 0x10(%r14), %rdi
movl $0x18, %r15d
testq %rdi, %rdi
je 0x153da
callq 0x15349
testq %rax, %rax
jne 0x153f6
movq (%r14,%r15), %rax
movq %rax, %r14
testq %rax, %rax
jne 0x1535c
jmp 0x153f9
xorl %ebx, %ebx
jmp 0x153f9
movq 0x28(%r14), %rbx
jmp 0x153f9
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x394a
leaq 0x13d1a(%rip), %rcx     # 0x29138
movq (%rcx), %r15
movl (%r15), %eax
leaq 0x8(%r15), %rcx
cmpl $0x5, %eax
jb 0x1541e
testl %ebx, %ebx
je 0x154c1
cmpl $0x5, %eax
jne 0x154a9
leaq 0x13cf7(%rip), %r12     # 0x29138
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x154ae
cmpl $0x258, (%rax)          # imm = 0x258
jne 0x154ae
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x154ae
cmpl %ebx, 0x48(%rax)
je 0x154ae
movl %ebx, %edi
callq 0x17238
movq %rax, %r14
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x14fc3
incl 0x1c(%r14)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
jne 0x15494
movq %r12, %rcx
jmp 0x15498
addq $0x8, %rcx
movq %rax, (%rcx)
movq 0x8(%r15), %r15
movl (%r15), %eax
cmpl $0x5, %eax
jb 0x1549b
je 0x15441
cmpl $0x9, %eax
je 0x154e0
movl $0x9, %edi
callq 0x3468
movl %ebx, %edi
callq 0x4dac
jmp 0x154d2
cmpl $0x9, %eax
je 0x154e0
movl $0x9, %edi
callq 0x3468
xorl %eax, %eax
leaq 0x13c5f(%rip), %rcx     # 0x29138
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_O3/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 0x172e7(%rip), %rax     # 0x2dd10
testq %rax, %rax
je 0x16a3b
movq 0x8(%rax), %rcx
movq %rcx, 0x172d7(%rip)     # 0x2dd10
jmp 0x16a70
leaq 0x13d2e(%rip), %rax     # 0x2a770
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x16a5f
movq %rdx, 0x8(%rcx)
jmp 0x16a70
leaq 0x13d0a(%rip), %rsi     # 0x2a770
movl $0x10, %edi
callq 0x17800
testq %r14, %r14
je 0x16a83
movq 0x8(%r14), %rcx
addq $0x8, %r14
movq %rcx, 0x8(%rax)
jmp 0x16a87
leaq 0x8(%rax), %r14
movq %rax, (%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16aaa
movq %rdi, %rcx
incl %eax
movq 0x8(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x16a9f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16d65
movl %eax, %eax
leaq 0x11bf0(%rip), %rcx     # 0x28950
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 0x16d87
testl %eax, %eax
js 0x16dbb
incq %rdi
jmp 0x16dbe
movb $0x2d, (%rdi)
subl %edi, %esi
callq 0x16b50
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/sym.c
// Function: constant
Symbol constant(ty, v) Type ty; Value v; {
	struct entry *p;
	unsigned h = v.u&(HASHSIZE-1);

	ty = unqual(ty);
	for (p = constants->buckets[h]; p; p = p->link)
		if (eqtype(ty, p->sym.type, 1))
			switch (ty->op) {
			case CHAR:     if (v.uc == p->sym.u.c.v.uc) return &p->sym; break;
			case SHORT:    if (v.ss == p->sym.u.c.v.ss) return &p->sym; break;
			case INT:      if (v.i  == p->sym.u.c.v.i)  return &p->sym; break;
			case UNSIGNED: if (v.u  == p->sym.u.c.v.u)  return &p->sym; break;
			case FLOAT:    if (v.f  == p->sym.u.c.v.f)  return &p->sym; break;
			case DOUBLE:   if (v.d  == p->sym.u.c.v.d)  return &p->sym; break;
			case ARRAY: case FUNCTION:
			case POINTER:  if (v.p  == p->sym.u.c.v.p)  return &p->sym; break;
			default: assert(0);
			}
	p = (struct entry *) alloc(sizeof *p);
	BZERO(&p->sym, struct symbol);
	p->sym.name = vtoa(ty, v);
	p->sym.scope = CONSTANTS;
	p->sym.type = ty;
	p->sym.sclass = STATIC;
	p->sym.u.c.v = v;
	p->link = constants->buckets[h];
	p->sym.up = constants->list;
	constants->list = &p->sym;
	constants->buckets[h] = p;
	p->refs = 0;	/* (omit) */
	defsymbol(&p->sym);
	return &p->sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl %r14d, %r12d
andl $0x7f, %r12d
cmpl $0xf, (%rdi)
jb 0x16def
movq 0x10(%r15), %r15
movq 0x12cb2(%rip), %rax     # 0x29aa8
movq 0x18(%rax,%r12,8), %rbx
testq %rbx, %rbx
je 0x16e89
movq %r14, 0x8(%rsp)
leaq 0x9d10(%rip), %r13      # 0x20b20
movq 0x20(%rbx), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x190d9
testl %eax, %eax
je 0x16e7d
movl (%r15), %eax
decl %eax
cmpl $0xb, %eax
ja 0x16f3c
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
cmpq %r14, 0x48(%rbx)
jne 0x16e7d
jmp 0x16f2b
cmpl %r14d, 0x48(%rbx)
jne 0x16e7d
jmp 0x16f2b
movsd 0x48(%rbx), %xmm0
ucomisd 0x8(%rsp), %xmm0
jne 0x16e7d
jp 0x16e7d
jmp 0x16f2b
cmpb %r14b, 0x48(%rbx)
jne 0x16e7d
jmp 0x16f2b
cmpw %r14w, 0x48(%rbx)
je 0x16f2b
movq 0x90(%rbx), %rbx
testq %rbx, %rbx
jne 0x16e10
leaq 0x138e0(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x98, (%rax)
movq 0x8(%rax), %rbx
leaq 0x98(%rbx), %rcx
cmpq 0x10(%rax), %rcx
jae 0x16eb0
movq %rcx, 0x8(%rax)
jmp 0x16ec4
leaq 0x138b9(%rip), %rsi     # 0x2a770
movl $0x98, %edi
callq 0x17800
movq %rax, %rbx
movl $0x88, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x14d05
movq %rax, 0x10(%rbx)
movw $0x1, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movb $0x51, 0x1a(%rbx)
movq %r14, 0x48(%rbx)
movq 0x12bad(%rip), %rax     # 0x29aa8
movq 0x18(%rax,%r12,8), %rcx
movq %rcx, 0x90(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x40(%rbx)
movq %rbx, 0x10(%rax)
movq %rbx, 0x18(%rax,%r12,8)
movq $0x0, 0x88(%rbx)
movq %rbx, %rdi
callq 0x1a458
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x7258(%rip), %rdi      # 0x1e19b
leaq 0x9c06(%rip), %rsi      # 0x20b50
leaq 0x9c0c(%rip), %rcx      # 0x20b5d
movl $0x37, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x1a146
movl 0x18da4(%rip), %esi     # 0x2fd30
movq 0x18dbd(%rip), %rax     # 0x2fd50
testq %rax, %rax
je 0x16fc9
leaq 0x18db1(%rip), %rcx     # 0x2fd50
movq (%rax), %rdx
movzwl 0x18(%rdx), %edi
cmpl %edi, %esi
je 0x16fbd
cmpb $0x0, 0x1a(%rdx)
je 0x16fbd
movq %rax, %rcx
movq 0x8(%rax), %rax
addq $0x8, %rcx
jmp 0x16fc4
movq 0x8(%rax), %rax
movq %rax, (%rcx)
testq %rax, %rax
jne 0x16f9f
movq 0x13318(%rip), %rdi     # 0x2a2e8
cmpl %esi, (%rdi)
jne 0x17043
leaq 0x15a7d(%rip), %rax     # 0x2ca58
cmpl $0x2, (%rax)
jl 0x1701a
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1701a
movl $0x80, %ecx
movzwl 0x18(%rax), %edx
cmpl %edx, %esi
jne 0x1701a
decl %ecx
je 0x17005
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0x16fee
jmp 0x1701a
leaq 0x9b8a(%rip), %rdi      # 0x20b96
xorl %eax, %eax
callq 0x9bfd
movq 0x132ce(%rip), %rdi     # 0x2a2e8
leaq 0x15a13(%rip), %rax     # 0x2ca34
cmpl $0x0, (%rax)
je 0x17032
callq 0x170fc
movq 0x132b6(%rip), %rdi     # 0x2a2e8
movq 0x8(%rdi), %rax
movq %rax, 0x132ab(%rip)     # 0x2a2e8
movl 0x18ced(%rip), %esi     # 0x2fd30
movq 0x136c6(%rip), %rdi     # 0x2a710
cmpl %esi, (%rdi)
jne 0x1708c
leaq 0x159df(%rip), %rax     # 0x2ca34
cmpl $0x0, (%rax)
je 0x17081
leaq 0x1a9(%rip), %rdx       # 0x1720a
xorl %ecx, %ecx
callq 0x17170
movq 0x136a1(%rip), %rdi     # 0x2a710
callq 0x170fc
movq 0x13695(%rip), %rdi     # 0x2a710
movl 0x18caf(%rip), %esi     # 0x2fd30
movq 0x8(%rdi), %rax
movq %rax, 0x13684(%rip)     # 0x2a710
cmpl $0x2, %esi
jle 0x1709b
decl %esi
movl %esi, 0x18c97(%rip)     # 0x2fd30
popq %rax
retq
leaq 0x9b23(%rip), %rdi      # 0x20bc5
leaq 0x9aa7(%rip), %rsi      # 0x20b50
leaq 0x9b25(%rip), %rcx      # 0x20bd5
movl $0x68, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x18c8f(%rip), %rax     # 0x2fd50
testq %rax, %rax
je 0x170fb
leaq 0x18c83(%rip), %rcx     # 0x2fd50
movq (%rax), %rdx
movzwl 0x18(%rdx), %r8d
cmpl %esi, %r8d
je 0x170e2
movzbl 0x1a(%rdx), %edx
cmpl %edi, %edx
jne 0x170eb
movq 0x8(%rax), %rax
movq %rax, (%rcx)
jmp 0x170f6
movq %rax, %rcx
movq 0x8(%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x170cd
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1592c(%rip), %rax     # 0x2ca34
cmpl $0x0, (%rax)
je 0x1716a
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x18(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x1715e
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x17134
xorl %esi, %esi
callq 0x16aab
movq %rax, 0x38(%r14)
movq $0x0, 0x88(%r14)
movq 0x18c12(%rip), %rsi     # 0x2fd58
movq %r14, %rdi
callq 0x16a18
movq %rax, 0x18c03(%rip)     # 0x2fd58
movq 0x90(%r14), %r14
jmp 0x17118
incq %r15
cmpq $0x80, %r15
jne 0x17113
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x171eb
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
cmpl %ebp, (%rdi)
jle 0x17198
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x17189
jmp 0x171de
jne 0x171de
leaq 0x15797(%rip), %r12     # 0x2c938
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x171d5
movzwl 0x18(%r15), %eax
cmpl %ebp, %eax
jne 0x171d5
movups 0x28(%r15), %xmm0
movups %xmm0, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
movq 0x40(%r15), %r15
jmp 0x171ae
movaps (%rsp), %xmm0
movups %xmm0, (%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x99f4(%rip), %rdi      # 0x20be6
leaq 0x9957(%rip), %rsi      # 0x20b50
leaq 0x99fb(%rip), %rcx      # 0x20bfb
movl $0x96, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x16d50
movq %rax, %r15
movq 0x18afa(%rip), %rsi     # 0x2fd48
movq %rax, %rdi
callq 0x1728e
movq %rax, %r14
testq %rax, %rax
jne 0x17285
leaq 0x18ae3(%rip), %rsi     # 0x2fd48
movq %r15, %rdi
xorl %edx, %edx
callq 0x172de
movq %rax, %r14
orb $0x4, 0x1b(%rax)
movl %ebx, 0x48(%rax)
movq %rax, 0x50(%rax)
movq %rax, %rdi
callq 0x1a458
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x172bf
movl %edi, %ecx
andl $0x7f, %ecx
movq 0x18(%rsi,%rcx,8), %rax
testq %rax, %rax
je 0x172b2
cmpq %rdi, 0x10(%rax)
je 0x172bd
movq 0x90(%rax), %rax
jmp 0x1729e
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x17299
xorl %eax, %eax
popq %rcx
retq
leaq 0x9920(%rip), %rdi      # 0x20be6
leaq 0x9883(%rip), %rsi      # 0x20b50
leaq 0x9936(%rip), %rcx      # 0x20c0a
movl $0xeb, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12ff3(%rip), %rax     # 0x2a2e8
cmpq %rax, %rsi
setne %al
leaq 0x1340e(%rip), %rcx     # 0x2a710
cmpq %rcx, %rsi
setne %cl
testb %cl, %al
jne 0x17321
movq (%rbx), %rdi
movl 0x18a1b(%rip), %esi     # 0x2fd30
cmpl %esi, (%rdi)
jge 0x17321
callq 0x17531
movq %rax, (%rbx)
testl %ebp, %ebp
je 0x1734f
leaq 0x13444(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x98, (%rax)
movq 0x8(%rax), %r15
leaq 0x98(%r15), %rcx
cmpq 0x10(%rax), %rcx
jb 0x17370
leaq 0x13423(%rip), %rsi     # 0x2a770
jmp 0x1737d
leaq 0x13422(%rip), %rax     # 0x2a778
movq (%rax), %rax
movl $0x98, (%rax)
movq 0x8(%rax), %r15
leaq 0x98(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x17376
movq %rcx, 0x8(%rax)
jmp 0x1738a
leaq 0x133fb(%rip), %rsi     # 0x2a778
movl $0x98, %edi
callq 0x17800
movq %rax, %r15
movl %r14d, %r12d
andl $0x7f, %r12d
movl $0x88, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x30e0
movq %r14, 0x10(%r15)
movq (%rbx), %rax
movzwl (%rax), %ecx
movw %cx, 0x18(%r15)
movq 0x10(%rax), %rax
movq %rax, 0x40(%r15)
movq (%rbx), %rax
movq %r15, 0x10(%rax)
movq (%rbx), %rax
shll $0x3, %r12d
movq 0x18(%rax,%r12), %rax
movq %rax, 0x90(%r15)
movq (%rbx), %rax
movq %r15, 0x18(%rax,%r12)
movq $0x0, 0x88(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12ef0(%rip), %rcx     # 0x2a2e8
testq %rcx, %rcx
je 0x17437
xorl %edx, %edx
movq 0x18(%rcx,%rdx,8), %rax
testq %rax, %rax
je 0x1741e
cmpq %rdi, 0x20(%rax)
jne 0x17415
cmpb $0x53, 0x1a(%rax)
je 0x17435
movq 0x90(%rax), %rax
jmp 0x17404
incq %rdx
cmpq $0x80, %rdx
jne 0x173ff
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x173fd
xorl %eax, %eax
popq %rcx
retq
leaq 0x97a8(%rip), %rdi      # 0x20be6
leaq 0x970b(%rip), %rsi      # 0x20b50
leaq 0x979d(%rip), %rcx      # 0x20be9
movl $0x85, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x17493
leaq 0x13300(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jb 0x174b4
leaq 0x132df(%rip), %rsi     # 0x2a770
jmp 0x174c1
leaq 0x132de(%rip), %rax     # 0x2a778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r15
leaq 0x88(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x174ba
movq %rcx, 0x8(%rax)
jmp 0x174ce
leaq 0x132b7(%rip), %rsi     # 0x2a778
movl $0x88, %edi
callq 0x17800
movq %rax, %r15
movl $0x88, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x30e0
movl 0x13235(%rip), %edi     # 0x2a718
leal 0x1(%rdi), %eax
movl %eax, 0x1322c(%rip)     # 0x2a718
callq 0x16d50
movq %rax, 0x10(%r15)
movw %bx, 0x18(%r15)
movb %bpl, 0x1a(%r15)
movq %r14, 0x20(%r15)
orb $0x4, 0x1b(%r15)
cmpl $0x3, %ebx
jg 0x17514
movq %r15, %rdi
callq 0x1a458
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13237(%rip), %rax     # 0x2a778
movq (%rax), %rax
movl $0x418, (%rax)          # imm = 0x418
movq 0x8(%rax), %rbx
leaq 0x418(%rbx), %rcx
cmpq 0x10(%rax), %rcx
jae 0x17561
movq %rcx, 0x8(%rax)
jmp 0x17575
leaq 0x13210(%rip), %rsi     # 0x2a778
movl $0x418, %edi            # imm = 0x418
callq 0x17800
movq %rax, %rbx
cmpl $0x4, %ebp
setge %al
cmpl $0x2, %ebp
sete %cl
orb %al, %cl
je 0x175b4
movq %r14, 0x8(%rbx)
movl %ebp, (%rbx)
testq %r14, %r14
je 0x17596
movq 0x10(%r14), %rax
jmp 0x17598
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 0x96be(%rip), %rdi      # 0x20c79
leaq 0x958e(%rip), %rsi      # 0x20b50
leaq 0x96ce(%rip), %rcx      # 0x20c97
movl $0x137, %edx            # imm = 0x137
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x17647
movq %rdi, %rax
movl %esi, %ecx
leaq 0x11638(%rip), %rdx     # 0x28c70
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rdi
movq %rax, %rsi
jmp 0x16dcc
pushq %rax
leaq 0x95cb(%rip), %rdi      # 0x20c1a
leaq 0x94fa(%rip), %rsi      # 0x20b50
leaq 0x95e7(%rip), %rcx      # 0x20c44
movl $0xf9, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x176a5
movl %esi, %eax
leaq 0x115f7(%rip), %rcx     # 0x28c70
movq (%rcx,%rax,8), %rax
movq (%rax), %rsi
callq 0x176c4
movq %rax, %rbx
movw $0x5, 0x18(%rax)
testb $0x1, 0x1b(%rax)
jne 0x176a0
movq %rbx, %rdi
callq 0x1aa39
orb $0x1, 0x1b(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x956e(%rip), %rdi      # 0x20c1a
leaq 0x949d(%rip), %rsi      # 0x20b50
leaq 0x95a6(%rip), %rcx      # 0x20c60
movl $0x103, %edx            # imm = 0x103
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x18684(%rip), %rax     # 0x2fd50
testq %rax, %rax
je 0x17710
leaq 0x18678(%rip), %rcx     # 0x2fd50
movq (%rax), %rdx
movzbl 0x1a(%rdx), %r8d
cmpl %edi, %r8d
jne 0x176fd
movq 0x20(%rdx), %rdx
movl 0x8(%rdx), %r8d
cmpl 0x8(%rsi), %r8d
jne 0x176fd
movzwl 0x4(%rdx), %edx
cmpw 0x4(%rsi), %dx
jge 0x17721
movq %rax, %rcx
movq 0x8(%rax), %rdx
addq $0x8, %rcx
movq %rdx, %rax
testq %rdx, %rdx
jne 0x176d8
movl 0x1861a(%rip), %edx     # 0x2fd30
callq 0x17456
orb $0x2, 0x1b(%rax)
popq %rcx
retq
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rax
movq %rsi, 0x20(%rax)
jmp 0x1771f
// File: /workspace/github_c_makefile_star2_O3/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 0x1778d
pushq %rbx
movq %rdi, %rbx
leaq 0x13036(%rip), %rax     # 0x2a778
movq (%rax), %rcx
movl $0x10, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x1775f
movq %rdx, 0x8(%rcx)
jmp 0x17770
leaq 0x13012(%rip), %rsi     # 0x2a778
movl $0x10, %edi
callq 0x17800
movq %rbx, (%rax)
movq 0x185d6(%rip), %rcx     # 0x2fd50
movq %rcx, 0x8(%rax)
movq %rax, 0x185cb(%rip)     # 0x2fd50
movl $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1529f(%rip), %rax     # 0x2ca34
cmpl $0x0, (%rax)
je 0x177ff
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x12fc1(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x177cc
movq %rcx, 0x8(%rax)
jmp 0x177e0
leaq 0x12f9d(%rip), %rsi     # 0x2a770
movl $0x10, %edi
callq 0x17800
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq 0x88(%rbx), %rsi
callq 0x16a18
movq %rax, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r12
movq 0x10(%r13), %rbp
leaq (%r12,%r8), %rax
cmpq %rbp, %rax
jbe 0x178f8
leaq 0x10(%r13), %r14
movq 0x1853c(%rip), %rax     # 0x2fd70
addl $0x2828, %edi           # imm = 0x2828
movslq %edi, %rbx
movq %r8, (%rsp)
movq 0x20(%r13), %rcx
testq %rcx, %rcx
je 0x1785a
leaq 0x28(%rcx), %r12
movq %r12, 0x8(%rcx)
movq %rax, %rdx
jmp 0x178db
testq %rax, %rax
je 0x1788e
movq %rax, 0x20(%r13)
movq 0x20(%rax), %rdx
movq %rdx, 0x18502(%rip)     # 0x2fd70
leaq 0x28(%rax), %r12
movq %r12, 0x8(%rax)
movq (%r15), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rax, %rcx
jmp 0x178db
movq %rbx, %rdi
callq 0x3150
movq %rax, 0x20(%r13)
testq %rax, %rax
je 0x17918
leaq (%rax,%rbx), %rcx
cmpq %rbp, %rax
je 0x178bc
movq %rcx, 0x10(%rax)
movq %rax, %r12
addq $0x28, %r12
movq %r12, 0x8(%rax)
movq %rax, %r13
jmp 0x178bf
movq %rcx, (%r14)
movq (%rsp), %r8
movq (%r15), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%r13)
movq $0x0, 0x20(%r13)
xorl %edx, %edx
movq %r13, %rcx
leaq (%r12,%r8), %rdi
leaq 0x10(%rcx), %r14
movq 0x10(%rcx), %rbp
movq %rcx, %r13
movq %rdx, %rax
cmpq %rbp, %rdi
ja 0x17841
jmp 0x178fb
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 0x94ed(%rip), %rdi      # 0x20e0c
leaq 0x94ef(%rip), %rsi      # 0x20e15
leaq 0x94f6(%rip), %rcx      # 0x20e23
movl $0x21, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/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 0x1842b(%rip), %rdx     # 0x2fd70
movq %rdx, 0x20(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x1841c(%rip)     # 0x2fd70
movq $0x0, 0x20(%rcx)
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16dcc
movq %rax, %rbx
movq 0x50(%rax), %rdi
testq %rdi, %rdi
jne 0x1799a
movq 0x8(%r14), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x17456
movq %rax, %rdi
movq %rax, 0x50(%rbx)
movq 0x8(%r14), %rax
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0x179ab
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0x179d9
movq %rax, %rdi
callq 0x18a0a
movl $0x107, %edi            # imm = 0x107
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x179e5
movq 0x50(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9d8b
// File: /workspace/github_c_makefile_star2_O3/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 0x1837b(%rip), %eax     # 0x2fd78
cmpq $0x63, %rax
ja 0x17a20
leal 0x1(%rax), %ecx
movl %ecx, 0x1836c(%rip)     # 0x2fd78
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
leaq 0x18365(%rip), %rax     # 0x2fd80
addq %rcx, %rax
jmp 0x17a52
movq 0x12d51(%rip), %rcx     # 0x2a778
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x17a41
movq %rdx, 0x8(%rcx)
jmp 0x17a52
leaq 0x12d30(%rip), %rsi     # 0x2a778
movl $0x30, %edi
callq 0x17800
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_O3/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
testq %rdi, %rdi
je 0x17aa4
movq %rdi, %rbx
movl $0x1, %ebp
movl (%rbx), %eax
andl $-0x10, %eax
cmpl $0xd0, %eax
je 0x17aa6
movq 0x10(%rbx), %rdi
callq 0x17a72
testl %eax, %eax
jne 0x17aa6
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x17a82
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17ad2
movl %eax, %eax
leaq 0x932b(%rip), %rcx      # 0x20df4
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 0x17af1
movl %edi, %eax
leaq 0x9274(%rip), %rcx      # 0x20d5c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x17af9
callq 0x16d50
movq %rax, %rsi
andl $0xf, %ebx
leal -0x1(%rbx), %eax
cmpl $0x8, %eax
ja 0x17b18
leaq 0x93e3(%rip), %rax      # 0x20eee
movsbl (%rbx,%rax), %edx
leaq 0x93d3(%rip), %rdi      # 0x20ee9
jmp 0x17b21
leaq 0x93da(%rip), %rdi      # 0x20ef9
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
jmp 0x11b33
// File: /workspace/github_c_makefile_star2_O3/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 0x17b4d
movl (%rbx), %edi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
callq 0x179e5
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17fc3(%rip), %ebx     # 0x2fd78
movl $0x64, 0x17fb9(%rip)    # 0x2fd78
movl %esi, %edi
callq *%rax
movl %ebx, 0x17faf(%rip)     # 0x2fd78
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1295b(%rip), %rcx     # 0x2a780
movq %rcx, %rdx
shlq $0x4, %rdx
leaq 0x1920d(%rip), %rsi     # 0x31040
movq %rdi, 0x8(%rdx,%rsi)
xorl %eax, %eax
leaq 0x19217(%rip), %r8      # 0x31058
incl %eax
leaq 0x10(%r8), %r9
cmpq %rdi, (%r8)
movq %r9, %r8
jne 0x17e41
cmpl %eax, %ecx
jne 0x17e62
incl %ecx
movl %ecx, 0x12925(%rip)     # 0x2a780
movl $0x0, (%rdx,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a817(%rip), %rsi     # 0x33040
testb %dl, %al
jne 0x1885b
movq (%rsi,%r13,8), %rax
testq %rax, %rax
je 0x1885b
cmpl %r12d, (%rax)
jne 0x18855
cmpq %r15, 0x10(%rax)
jne 0x18855
cmpl %r14d, 0x8(%rax)
jne 0x18855
movswl 0x4(%rax), %ecx
cmpl %ebp, %ecx
jne 0x18855
cmpq %rbx, 0x18(%rax)
je 0x188bd
movq 0x28(%rax), %rax
jmp 0x18831
leaq 0x11f0e(%rip), %rax     # 0x2a770
movq (%rax), %rcx
movl $0x30, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x30(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x1887f
movq %rdx, 0x8(%rcx)
jmp 0x18897
leaq 0x11eea(%rip), %rsi     # 0x2a770
movl $0x30, %edi
callq 0x17800
leaq 0x1a7a9(%rip), %rsi     # 0x33040
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_O3/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
testq %rdi, %rdi
je 0x1892f
movq %rdi, %r14
leaq 0x8d0e(%rip), %r15      # 0x21612
movl (%r14), %eax
cmpl $0xf, %eax
jb 0x18912
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xb, %eax
jne 0x18932
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x974c
movq 0x1a66b(%rip), %r14     # 0x32f98
jmp 0x18904
xorl %r14d, %r14d
testl %ebx, %ebx
jne 0x1893b
movswl 0x4(%r14), %ebx
leaq 0x173ee(%rip), %rax     # 0x2fd30
cmpl $0x4, (%rax)
jl 0x1896f
movl (%r14), %eax
cmpl $0xf, %eax
jb 0x18955
movq 0x10(%r14), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x1896f
cmpl $0x0, 0x8(%r14)
jne 0x1896f
leaq 0x8cc6(%rip), %rdi      # 0x2162e
xorl %eax, %eax
callq 0x974c
movl 0x8(%r14), %ecx
testl %ecx, %ecx
je 0x189a1
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
idivl %ecx
cmpl %ebp, %eax
jge 0x189e7
leaq 0x8ce2(%rip), %rdi      # 0x2166d
movq %r14, %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %eax, %eax
callq 0x974c
movl $0x1, %ebp
jmp 0x189e7
cmpl $0xf, (%r14)
movq %r14, %rax
jb 0x189ae
movq 0x10(%r14), %rax
cmpq 0x1a62b(%rip), %rax     # 0x32fe0
je 0x189d6
leaq 0x1409a(%rip), %rax     # 0x2ca58
cmpl $0x2, (%rax)
jl 0x189e7
leaq 0x8c78(%rip), %rdi      # 0x21642
movq %r14, %rsi
xorl %eax, %eax
callq 0x9bfd
jmp 0x189e7
leaq 0x8c35(%rip), %rdi      # 0x21612
movq %r14, %rsi
xorl %eax, %eax
callq 0x974c
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 0x187eb
// File: /workspace/github_c_makefile_star2_O3/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 0x18a1b
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpl $0xc, %eax
jne 0x18a32
movq 0x10(%rbx), %rsi
movq 0x1a5bd(%rip), %r8      # 0x32fe8
movl $0x7, %edi
jmp 0x18a56
leaq 0x8c5c(%rip), %rdi      # 0x21695
leaq 0x8c65(%rip), %rsi      # 0x216a5
xorl %eax, %eax
callq 0x974c
movq 0x1a59a(%rip), %r8      # 0x32fe8
movl $0x7, %edi
movq %rbx, %rsi
movl $0x2, %edx
movl $0x1, %ecx
popq %rbx
jmp 0x187eb
// File: /workspace/github_c_makefile_star2_O3/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 0x18a9e
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0x18a95
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x18aa6
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x18a7c
addq $0x8, %rsp
popq %rbx
popq %r14
retq