LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: deftype
Symbol deftype(name, ty, pos) char *name; Type ty; Coordinate *pos; {
	Symbol p = lookup(name, identifiers);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x100f4(%rip), %rax     # 0x292e8
movq (%rax), %rsi
callq 0x173d9
testq %rax, %rax
je 0x19221
movzwl 0x18(%rax), %eax
leaq 0x15b24(%rip), %rcx     # 0x2ed30
cmpl %eax, (%rcx)
jne 0x19221
leaq 0x842e(%rip), %rdi      # 0x21645
movq %r15, %rsi
xorl %eax, %eax
callq 0x9720
leaq 0x15b08(%rip), %rax     # 0x2ed30
xorl %edx, %edx
cmpl $0x5, (%rax)
setl %dl
leaq 0x100b1(%rip), %rsi     # 0x292e8
movq %r15, %rdi
callq 0x17429
movq %r14, 0x20(%rax)
movb $0x53, 0x1a(%rax)
movups (%rbx), %xmm0
movups %xmm0, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: deref
Type deref(ty) Type ty; {
	if (isptr(ty))
		ty = ty->type;
	else
		error("type error: %s\n", "pointer expected");
	return isenum(ty) ? unqual(ty)->type : ty;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x19264
movq 0x10(%rbx), %rax
cmpl $0x7, (%rax)
jne 0x1926f
movq 0x10(%rbx), %rbx
jmp 0x19284
leaq 0x839f(%rip), %rdi      # 0x21615
leaq 0x83df(%rip), %rsi      # 0x2165c
xorl %eax, %eax
callq 0x9720
movl (%rbx), %eax
movq %rbx, %rcx
cmpl $0xf, %eax
jb 0x19292
movq 0x10(%rbx), %rcx
cmpl $0xd, (%rcx)
jne 0x192a4
cmpl $0xf, %eax
jb 0x192a0
movq 0x10(%rbx), %rbx
movq 0x10(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: extends
Field extends(ty, fty) Type ty, fty; {
	Field p, q;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0xf, (%rdi)
jb 0x19499
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %rax
movq 0x58(%rax), %rbx
testq %rbx, %rbx
je 0x194e9
movq (%rbx), %rax
testq %rax, %rax
jne 0x194e3
movq 0x8(%rbx), %rcx
cmpl $0xf, (%rcx)
jb 0x194bb
movq 0x10(%rcx), %rcx
cmpl $0xf, (%r14)
movq %r14, %rdx
jb 0x194c8
movq 0x10(%r14), %rdx
cmpq %rdx, %rcx
je 0x194eb
testq %rax, %rax
jne 0x194e3
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x19489
testq %rax, %rax
jne 0x194f6
movq 0x18(%rbx), %rbx
jmp 0x194a1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x18b04(%rip)    # 0x32008
movups %xmm0, 0x18aed(%rip)    # 0x31ff8
movl 0x10(%rax), %eax
addl 0x10(%rbx), %eax
leaq 0x18ae0(%rip), %rbx     # 0x31ff8
movl %eax, 0x18aea(%rip)     # 0x32008
jmp 0x194eb
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: fieldlist
Field fieldlist(ty) Type ty; {
	Field p, q, t, inherited = 0, *r;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rsp)
cmpl $0xf, (%rdi)
jb 0x1953c
movq 0x10(%rbx), %rbx
movq 0x18(%rbx), %rcx
movq (%rsp), %rax
movq 0x58(%rcx), %r14
testq %r14, %r14
je 0x1956c
cmpq $0x0, (%r14)
jne 0x19566
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x18c18
movq 0x18(%r14), %r14
jmp 0x19548
movq %rax, (%rsp)
testq %rax, %rax
je 0x19684
xorl %ecx, %ecx
movq %rax, %r14
movq 0x18(%rax), %rax
movq %rcx, 0x18(%r14)
movq %r14, %rcx
testq %rax, %rax
jne 0x1957b
movq 0x18(%rbx), %rax
movq 0x58(%rax), %r15
movq %rsp, %r12
testq %r15, %r15
je 0x1961a
leaq 0x101d3(%rip), %rbx     # 0x29778
cmpq $0x0, (%r15)
je 0x1960c
movl 0x10(%r15), %eax
cmpl 0x10(%r14), %eax
jle 0x195c6
movq %r14, (%r12)
movq %r14, %r12
movq 0x18(%r14), %r14
addq $0x18, %r12
jmp 0x19610
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x195e3
movq %rdx, 0x8(%rcx)
jmp 0x195f0
movl $0x20, %edi
movq %rbx, %rsi
callq 0x17978
movq %rax, (%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x1961a
testq %r14, %r14
jne 0x195a5
testq %r15, %r15
je 0x1967b
leaq 0x10152(%rip), %rbx     # 0x29778
cmpq $0x0, (%r15)
je 0x19672
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x19649
movq %rdx, 0x8(%rcx)
jmp 0x19656
movl $0x20, %edi
movq %rbx, %rsi
callq 0x17978
movq %rax, (%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x19626
movq %r14, (%r12)
movq %rsp, %rax
jmp 0x1968c
movq 0x18(%rbx), %rax
addq $0x58, %rax
movq (%rax), %rax
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/types.c
// Function: fieldref
Field fieldref(name, ty) char *name; Type ty; {
	Field p = isfield(name, unqual(ty)->u.sym->u.s.flist);
	if (p) {
		if (xref) {
			Symbol q;
			assert(unqual(ty)->u.sym->u.s.ftab);
			q = lookup(name, unqual(ty)->u.sym->u.s.ftab);
			assert(q);
			use(q, src);
		}
		return p;
	}
	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link) {
		Field q;
		if (p->name == 0 && (q = fieldref(name, p->type))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rsi), %eax
movq %rsi, %rcx
cmpl $0xf, %eax
jb 0x196b1
movq 0x10(%rsi), %rcx
movq 0x18(%rcx), %rcx
movq 0x58(%rcx), %rbx
testq %rbx, %rbx
je 0x196c9
cmpq %r14, (%rbx)
je 0x196c9
movq 0x18(%rbx), %rbx
jmp 0x196b9
testq %rbx, %rbx
je 0x19736
leaq 0x1235f(%rip), %rcx     # 0x2ba34
cmpl $0x0, (%rcx)
je 0x1972d
movq %rsi, %rcx
cmpl $0xf, %eax
jb 0x196e6
movq 0x10(%rsi), %rcx
movq 0x18(%rcx), %rcx
cmpq $0x0, 0x50(%rcx)
je 0x19796
cmpl $0xf, %eax
jb 0x196fe
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %rax
movq 0x50(%rax), %rsi
movq %r14, %rdi
callq 0x173d9
testq %rax, %rax
je 0x197b5
leaq 0x1221a(%rip), %rcx     # 0x2b938
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x17906
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0xf, %eax
jb 0x1973f
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %rax
movq 0x58(%rax), %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x1972d
cmpq $0x0, (%r15)
jne 0x19765
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x1969b
testq %rax, %rax
jne 0x1976b
movq 0x18(%r15), %r15
jmp 0x19749
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x188af(%rip)    # 0x32028
movups %xmm0, 0x18898(%rip)    # 0x32018
leaq 0x18891(%rip), %rbx     # 0x32018
movl 0x10(%rax), %eax
addl 0x10(%r15), %eax
movl %eax, 0x18894(%rip)     # 0x32028
jmp 0x1972d
leaq 0x7edd(%rip), %rdi      # 0x2167a
leaq 0x7a04(%rip), %rsi      # 0x211a8
leaq 0x7eeb(%rip), %rcx      # 0x21696
movl $0x13d, %edx            # imm = 0x13D
callq 0x30d0
leaq 0x5a4d(%rip), %rdi      # 0x1f209
leaq 0x79e5(%rip), %rsi      # 0x211a8
leaq 0x7ecc(%rip), %rcx      # 0x21696
movl $0x13f, %edx            # imm = 0x13F
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: hasproto
int hasproto(ty) Type ty; {
	if (Aflag < 1 || ty == 0)
		return 1;
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE: case POINTER:
	case ARRAY:
		return hasproto(ty->type);
	case FUNCTION:
		return hasproto(ty->type) && ty->u.proto;
	case STRUCT: case UNION:
	case CHAR:   case SHORT: case INT:  case DOUBLE:
	case VOID:   case FLOAT: case ENUM: case UNSIGNED:
		return 1;
	default:
		assert(0);
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x12240(%rip), %rax     # 0x2ba58
movl (%rax), %ecx
movl $0x80019080, %edx       # imm = 0x80019080
movl $0x1, %eax
testq %rbx, %rbx
je 0x19849
testl %ecx, %ecx
jle 0x19849
movl (%rbx), %esi
cmpl $0x1f, %esi
ja 0x1986d
btl %esi, %edx
jae 0x1983f
movq 0x10(%rbx), %rbx
jmp 0x19824
movl $0x277e, %ecx           # imm = 0x277E
btl %esi, %ecx
jae 0x1984b
popq %rbx
retq
cmpl $0xb, %esi
jne 0x1986d
movq 0x10(%rbx), %rdi
callq 0x1980d
testl %eax, %eax
je 0x19869
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
setne %al
jmp 0x19849
xorl %eax, %eax
jmp 0x19849
leaq 0x4927(%rip), %rdi      # 0x1e19b
leaq 0x792d(%rip), %rsi      # 0x211a8
leaq 0x7e51(%rip), %rcx      # 0x216d3
movl $0x173, %edx            # imm = 0x173
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newfield
Field newfield(name, ty, fty) char *name; Type ty, fty; {
	Field p, *q = &ty->u.sym->u.s.flist;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r13
addq $0x58, %r13
testq %rdi, %rdi
jne 0x198bf
movl $0x1, %edi
callq 0x1769a
movl %eax, %edi
callq 0x16e2f
movq %rax, %r14
movq (%r13), %rax
testq %rax, %rax
je 0x198f4
leaq 0x7e13(%rip), %r12      # 0x216e2
movq %rax, %r13
cmpq %r14, (%rax)
jne 0x198e7
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9720
movq 0x18(%r13), %rax
testq %rax, %rax
jne 0x198cf
addq $0x18, %r13
leaq 0xfe75(%rip), %rax      # 0x29770
movq (%rax), %rax
movl $0x20, (%rax)
movq 0x8(%rax), %r12
leaq 0x20(%r12), %rcx
cmpq 0x10(%rax), %rcx
jae 0x19919
movq %rcx, 0x8(%rax)
jmp 0x1992d
leaq 0xfe50(%rip), %rsi      # 0x29770
movl $0x20, %edi
callq 0x17978
movq %rax, %r12
movq %r12, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movups %xmm0, 0x10(%r12)
movq %r14, (%r12)
movq %r15, 0x8(%r12)
leaq 0x120e5(%rip), %rax     # 0x2ba34
cmpl $0x0, (%rax)
je 0x1999a
movq 0x18(%rbx), %rax
cmpq $0x0, 0x50(%rax)
jne 0x19977
leaq 0x153ca(%rip), %rax     # 0x2ed30
movl (%rax), %esi
xorl %edi, %edi
callq 0x176a9
movq 0x18(%rbx), %rcx
movq %rax, 0x50(%rcx)
movq 0x18(%rbx), %rsi
addq $0x50, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x17429
leaq 0x11fa5(%rip), %rcx     # 0x2b938
movups (%rcx), %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newstruct
Type newstruct(op, tag) int op; char *tag; {
	Symbol p;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testq %rsi, %rsi
je 0x199ba
movq %rsi, %r14
cmpb $0x0, (%rsi)
jne 0x199ce
movl $0x1, %edi
callq 0x1769a
movl %eax, %edi
callq 0x16e2f
movq %rax, %r14
leaq 0xfd3b(%rip), %rax      # 0x29710
movq (%rax), %rsi
movq %r14, %rdi
callq 0x173d9
testq %rax, %rax
je 0x19a26
movzwl 0x18(%rax), %edx
leaq 0x15340(%rip), %rcx     # 0x2ed30
movl (%rcx), %ecx
cmpl %edx, %ecx
je 0x19a07
cmpw $0x4, %dx
setne %dl
cmpl $0x5, %ecx
setne %cl
orb %dl, %cl
jne 0x19a26
movq 0x20(%rax), %rcx
cmpl %ebx, (%rcx)
jne 0x19a15
testb $0x1, 0x1b(%rax)
je 0x19a76
leaq 0x7c29(%rip), %rdi      # 0x21645
movq %r14, %rsi
xorl %eax, %eax
callq 0x9720
leaq 0xfce3(%rip), %rsi      # 0x29710
movq %r14, %rdi
movl $0x1, %edx
callq 0x17429
movq %rax, %r14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x18963
movq %rax, %rcx
movq %rax, 0x20(%r14)
movzwl 0x18(%r14), %eax
cmpl %eax, 0x185d9(%rip)     # 0x32038
jge 0x19a67
movl %eax, 0x185d1(%rip)     # 0x32038
leaq 0x11eca(%rip), %rax     # 0x2b938
movups (%rax), %xmm0
movups %xmm0, 0x28(%r14)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printdecl
void printdecl(p, ty) Symbol p; Type ty; {
	switch (p->sclass) {
	case AUTO:
		fprint(2, "%s;\n", typestring(ty, p->name));
		break;
	case STATIC: case EXTERN:
		fprint(2, "%k %s;\n", p->sclass, typestring(ty, p->name));
	case TYPEDEF: case ENUM:
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbx
movzbl 0x1a(%rdi), %ebx
cmpl $0x49, %ebx
jle 0x19d38
cmpl $0x4a, %ebx
je 0x19d68
cmpl $0x51, %ebx
je 0x19d68
cmpl $0x53, %ebx
je 0x19d90
jmp 0x19d92
cmpl $0xd, %ebx
je 0x19d90
cmpl $0x43, %ebx
jne 0x19d92
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x19db1
leaq 0x7a38(%rip), %rsi      # 0x21790
movl $0x2, %edi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x116f4
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x19db1
leaq 0x7a0f(%rip), %rsi      # 0x2178d
movl $0x2, %edi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x116f4
popq %rbx
retq
leaq 0x4402(%rip), %rdi      # 0x1e19b
leaq 0x7408(%rip), %rsi      # 0x211a8
leaq 0x79ee(%rip), %rcx      # 0x21795
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printproto
void printproto(p, callee) Symbol p, callee[]; {
	if (p->type->u.proto)
		printdecl(p, p->type);
	else {
		int i;
		List list = 0;
		if (callee[0] == 0)
			list = append(voidtype, list);
		else
			for (i = 0; callee[i]; i++)
				list = append(callee[i]->type, list);
		printdecl(p, funcl(freturn(p->type), list));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
cmpq $0x0, 0x18(%rsi)
jne 0x1a1ed
cmpq $0x0, (%r15)
je 0x1a192
movq (%r15), %rax
testq %rax, %rax
je 0x1a1a5
addq $0x8, %r15
xorl %r14d, %r14d
movq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0x16aec
movq %rax, %r14
movq (%r15), %rax
addq $0x8, %r15
testq %rax, %rax
jne 0x1a175
jmp 0x1a1a8
movq 0x17e47(%rip), %rdi     # 0x31fe0
xorl %esi, %esi
callq 0x16aec
movq %rax, %r14
jmp 0x1a1a8
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
cmpl $0xf, (%rax)
movq %rax, %rcx
jb 0x1a1b8
movq 0x10(%rax), %rcx
cmpl $0xb, (%rcx)
jne 0x1a1c3
addq $0x10, %rax
jmp 0x1a1df
leaq 0x744b(%rip), %rdi      # 0x21615
leaq 0x74d6(%rip), %rsi      # 0x216a7
xorl %eax, %eax
callq 0x9720
leaq 0x17db9(%rip), %rax     # 0x31f98
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1917b
movq %rax, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19d1d
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printtype
void printtype(Type ty, int fd) {
	switch (ty->op) {
	case STRUCT: case UNION: {
		Field p;
		fprint(fd, "%k %s size=%d {\n", ty->op, ty->u.sym->name, ty->size);
		for (p = ty->u.sym->u.s.flist; p; p = p->link) {
			fprint(fd, "field %s: offset=%d", p->name, p->offset);
			if (p->to)
				fprint(fd, " bits=%d..%d", p->from, p->to);
			fprint(fd, " type=%t", p->type);
		}
		fprint(fd, "}\n");
		break;
		}
	case ENUM: {
		int i;
		Symbol p;
		fprint(fd, "enum %s {", ty->u.sym->name);
		for (i = 0; (p = ty->u.sym->u.idlist[i]); i++) {
			if (i > 0)
				fprint(fd, ",");
			fprint(fd, "%s=%d", p->name, p->u.value);
		}
		fprint(fd, "}\n");
		break;
		}
	default:
		fprint(fd, "%t\n", ty);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jae 0x1a2a3
movq 0x18(%r14), %rax
movq 0x10(%rax), %rcx
movl 0x8(%r14), %r8d
leaq 0x757b(%rip), %rsi      # 0x217a6
movl %ebx, %edi
xorl %eax, %eax
callq 0x116f4
movq 0x18(%r14), %rax
movq 0x58(%rax), %r13
testq %r13, %r13
je 0x1a31e
leaq 0x756b(%rip), %r14      # 0x217b7
leaq 0x7585(%rip), %r15      # 0x217d8
leaq 0x7571(%rip), %r12      # 0x217cb
movq (%r13), %rdx
movl 0x10(%r13), %ecx
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x116f4
movswl 0x16(%r13), %ecx
testl %ecx, %ecx
je 0x1a288
movswl 0x14(%r13), %edx
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x116f4
movq 0x8(%r13), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x116f4
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x1a25a
jmp 0x1a31e
cmpl $0xd, %edx
jne 0x1a33c
movq 0x18(%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x7526(%rip), %rsi      # 0x217e1
movl %ebx, %edi
xorl %eax, %eax
callq 0x116f4
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
movq (%rax), %rbp
testq %rbp, %rbp
je 0x1a31e
leaq 0x7510(%rip), %r15      # 0x217eb
leaq 0x5c4a(%rip), %r12      # 0x1ff2c
xorl %r13d, %r13d
testq %r13, %r13
je 0x1a2f6
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x116f4
movq 0x10(%rbp), %rdx
movl 0x48(%rbp), %ecx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x116f4
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax,%r13,8), %rbp
incq %r13
testq %rbp, %rbp
jne 0x1a2e5
leaq 0x5be4(%rip), %rsi      # 0x1ff09
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
leaq 0x74ae(%rip), %rsi      # 0x217f1
movl %ebx, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x116f4
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: rmtypes
void rmtypes() {
	if (maxlevel >= level) {
		int i;
		maxlevel = 0;
		for (i = 0; i < sizeof typetable/sizeof typetable[0]; i++) {
			struct type *tn, **tq = &typetable[i];
			for (tn = *tq; tn; tn = *tq)
				if (tn->type.op == FUNCTION)
					tq = &tn->link;
				else if (tn->type.u.sym && tn->type.u.sym->scope == level)
					*tq = tn->link;
				else {
					if (tn->type.u.sym && tn->type.u.sym->scope > maxlevel)
						maxlevel = tn->type.u.sym->scope;
					tq = &tn->link;
				}
		}
	}
}

// Assembly:
leaq 0x149cc(%rip), %rax     # 0x2ed30
movl (%rax), %eax
cmpl %eax, 0x17ccc(%rip)     # 0x32038
jl 0x1a3e5
movl $0x0, 0x17cc0(%rip)     # 0x32038
xorl %ecx, %ecx
leaq 0x17cbf(%rip), %rdx     # 0x32040
xorl %esi, %esi
movq (%rdx,%rcx,8), %rdi
testq %rdi, %rdi
je 0x1a3d9
leaq (%rdx,%rcx,8), %r8
cmpl $0xb, (%rdi)
je 0x1a3ca
movq 0x18(%rdi), %r9
testq %r9, %r9
je 0x1a3ca
movzwl 0x18(%r9), %r10d
cmpl %r10d, %eax
jne 0x1a3b1
movq 0x28(%rdi), %rdi
movq %rdi, (%r8)
jmp 0x1a3d1
testq %r9, %r9
je 0x1a3ca
movzwl 0x18(%r9), %r8d
cmpl %r8d, %esi
jge 0x1a3ca
movl %r8d, 0x17c71(%rip)     # 0x32038
movl %r8d, %esi
addq $0x28, %rdi
movq %rdi, %r8
movq (%r8), %rdi
testq %rdi, %rdi
jne 0x1a390
incq %rcx
cmpq $0x80, %rcx
jne 0x1a383
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: ttob
int ttob(ty) Type ty; {
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE:
		return ttob(ty->type);
	case VOID: case CHAR: case INT: case SHORT:
	case UNSIGNED: case FLOAT: case DOUBLE:
		return ty->op;
	case POINTER: case FUNCTION:
		return POINTER;
	case ARRAY: case STRUCT: case UNION:
		return STRUCT;
	case ENUM:
		return INT;
	default:
		assert(0);
	}
	return I;
}

// Assembly:
pushq %rax
leaq 0x6d02(%rip), %rcx      # 0x210f0
movl (%rdi), %eax
leal -0x1(%rax), %edx
cmpl $0x1e, %edx
ja 0x1a41c
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq 0x10(%rdi), %rdi
jmp 0x1a3ee
movl $0x9, %eax
jmp 0x1a41a
movl $0x7, %eax
jmp 0x1a41a
movl $0x5, %eax
popq %rcx
retq
leaq 0x3d78(%rip), %rdi      # 0x1e19b
leaq 0x6d7e(%rip), %rsi      # 0x211a8
leaq 0x73fb(%rip), %rcx      # 0x2182c
movl $0x26c, %edx            # imm = 0x26C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: variadic
int variadic(ty) Type ty; {
	if (isfunc(ty) && ty->u.proto) {
		int i;
		for (i = 0; ty->u.proto[i]; i++)
			;
		return i > 1 && ty->u.proto[i-1] == voidtype;
	}
	return 0;
}

// Assembly:
cmpl $0xf, (%rdi)
movq %rdi, %rcx
jb 0x1a447
movq 0x10(%rdi), %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x1a481
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1a481
movq $-0x1, %rdx
cmpq $0x0, 0x8(%rcx,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x1a45e
cmpq $0x2, %rdx
jb 0x1a481
movq -0x8(%rcx,%rdx,8), %rcx
xorl %eax, %eax
cmpq 0x17b62(%rip), %rcx     # 0x31fe0
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defsymbol
void defsymbol(Symbol p) {
    if (p->x.name) return;
    if (p->scope == CONSTANTS) {
        p->x.name = p->name;
        if (p->x.name[0]=='0' && p->x.name[1]=='x') {
            p->x.name[0]=' '; p->x.name[1]='$';
        }
    } else if (p->sclass == STATIC)
        p->x.name = stringf("L%s%d", NamePrefix, genlabel(1));
    else if (p->generated)
        p->x.name = stringf("L%s%s", NamePrefix, p->name);
    else
        p->x.name = stringf("_%s", p->name);
    p->x.adrmode = 'C';

}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1a68e
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x18(%rdi)
jne 0x1a6ba
movq 0x10(%rbx), %rax
movq %rax, (%rbx)
cmpb $0x30, (%rax)
jne 0x1a71c
cmpb $0x78, 0x1(%rax)
jne 0x1a71c
movb $0x20, (%rax)
movq (%rbx), %rax
movb $0x24, 0x1(%rax)
jmp 0x1a71c
cmpb $0x51, 0x1a(%rbx)
jne 0x1a6e6
movq 0x17d79(%rip), %r14     # 0x32440
movl $0x1, %edi
callq 0x1769a
leaq 0x7830(%rip), %rdi      # 0x21f08
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x11c7f
jmp 0x1a719
testb $0x4, 0x1b(%rbx)
jne 0x1a700
movq 0x10(%rbx), %rsi
leaq 0x781d(%rip), %rdi      # 0x21f14
xorl %eax, %eax
callq 0x11c7f
jmp 0x1a719
movq 0x17d39(%rip), %rsi     # 0x32440
movq 0x10(%rbx), %rdx
leaq 0x77fc(%rip), %rdi      # 0x21f0e
xorl %eax, %eax
callq 0x11c7f
movq %rax, (%rbx)
movb $0x43, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: printfloat
void printfloat(double val)
{
    int i,exp=32,negative=0;
    double two_pow31,two_pow32;
    unsigned long mantissa;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a793
jp 0x1a793
leaq 0x77bb(%rip), %rbx      # 0x21f18
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1187e
movapd 0x5a15(%rip), %xmm3     # 0x201b0
xorpd %xmm0, %xmm3
movsd 0x5a51(%rip), %xmm1     # 0x201f8
movl $0x1f, %eax
addsd %xmm1, %xmm1
decl %eax
jne 0x1a7ac
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
cmpnltsd %xmm4, %xmm2
movapd %xmm2, %xmm4
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
movapd %xmm1, %xmm3
addsd %xmm1, %xmm3
movl $0x20, %esi
ucomisd %xmm3, %xmm2
jb 0x1a800
movsd 0x70e4(%rip), %xmm4     # 0x218d0
mulsd %xmm4, %xmm2
incl %esi
ucomisd %xmm3, %xmm2
jae 0x1a7ec
jmp 0x1a800
addsd %xmm2, %xmm2
decl %esi
ucomisd %xmm2, %xmm1
ja 0x1a7fa
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
cmpnltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x70a5(%rip), %xmm0     # 0x218d8
cvttsd2si %xmm0, %r14
sarq $0x3f, %rcx
andq %rcx, %r14
orq %rax, %r14
subl $-0x80, %esi
leaq 0x76d4(%rip), %rbx      # 0x21f20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movl %r14d, %esi
shrl $0x10, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movl %r14d, %esi
shrl $0x8, %esi
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1187e
movzbl %r14b, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1187e
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defconst
void defconst(int ty, Value v) {
    if (graph_output) return;
    switch (ty) {
    case C: print("\tDB(%d)\n",   v.uc); break;
    case S: print("\tDB(%d)\n",   v.us); break;
    case I: print("\tDW(%d)\n",   v.i ); break;
    case U: print("\tDW($%x)\n",  v.u ); break;
    case P: print("\tDW($%x)\n",  v.p ); break;
    case F: printfloat(v.f); break;
    case D: printfloat(v.d); break;
    default: assert(0);
    }
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
cmpb $0x0, 0x17b9b(%rip)     # 0x32448
je 0x1a8b1
popq %rax
retq
decl %edi
cmpl $0x6, %edi
ja 0x1a917
movq %rsi, %xmm0
leaq 0x701c(%rip), %rax      # 0x218e0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rax
jmp 0x1a746
movl (%rsp), %esi
leaq 0x7656(%rip), %rdi      # 0x21f33
jmp 0x1a8fc
movzbl (%rsp), %esi
jmp 0x1a8e9
movzwl (%rsp), %esi
leaq 0x763a(%rip), %rdi      # 0x21f2a
jmp 0x1a8fc
movl (%rsp), %esi
leaq 0x7640(%rip), %rdi      # 0x21f3c
xorl %eax, %eax
popq %rcx
jmp 0x1187e
movq (%rsp), %rsi
leaq 0x762d(%rip), %rdi      # 0x21f3c
xorl %eax, %eax
popq %rcx
jmp 0x1187e
leaq 0x387d(%rip), %rdi      # 0x1e19b
leaq 0x7621(%rip), %rsi      # 0x21f46
leaq 0x7627(%rip), %rcx      # 0x21f53
movl $0x122, %edx            # imm = 0x122
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defstring
void defstring(int len, char *s) {
    if (graph_output) return;
    while (len > 0) {
        print("\tDB($%x)\n",(unsigned char)*s++);
        len--;
    }
}

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0xeb39(%rip)      # 0x297c8
jl 0x1acae
cmpb $0x4e, 0x1a(%rbx)
jne 0x1acae
movslq 0x179f2(%rip), %rax     # 0x32690
cmpq $0x8, %rax
je 0x1acae
movq 0x20(%rbx), %rcx
cmpl $0x5, 0x8(%rcx)
jne 0x1acfb
movq (%rbx), %rax
testq %rax, %rax
je 0x1acbb
cmpb $0x2a, (%rax)
jne 0x1acf9
leaq 0x731a(%rip), %rax      # 0x21fdc
cmpb $0x0, 0x1777f(%rip)     # 0x32448
leaq 0x7316(%rip), %rdi      # 0x21fe6
cmovneq %rax, %rdi
movl 0x179ba(%rip), %esi     # 0x32694
xorl %eax, %eax
callq 0x11c7f
movq %rax, (%rbx)
movb $0x41, 0x8(%rbx)
movb $0x43, 0x1a(%rbx)
movq 0x20(%rbx), %rax
movl 0x8(%rax), %eax
addl %eax, 0x1799b(%rip)     # 0x32694
popq %rbx
retq
leaq 0x1774e(%rip), %rcx     # 0x32450
movq (%rcx,%rax,8), %rcx
movq %rcx, (%rbx)
movb $0x52, 0x8(%rbx)
incl %eax
movl %eax, 0x1797b(%rip)     # 0x32690
jmp 0x1acf9
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: linearize
static Node *linearize(Node p, Node *last, Node next) {
    if (p && !p->x.visited) {
        if ( optimizelevel>0 ) {
            switch (generic(p->op)) {
            case CNST:
            case ADDRG: case ADDRL: case ADDRF:
                p->x.optimized=1;
                p->x.result=p->syms[0];
                p->x.adrmode=p->syms[0]->x.adrmode;
                p->x.name=p->syms[0]->x.name;
                return last;
            }
        }
        last = linearize(p->kids[0], last, NULL);
        last = linearize(p->kids[1], last, NULL);
        p->x.visited = 1;
        *last = p;
        last = &p->x.next;
    }
    *last = next;
    return last;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6544(%rip), %r15      # 0x21896
leaq 0x5b12(%rip), %r12      # 0x20e6b
movzbl (%r14), %eax
cmpl $0x25, %eax
je 0x1b368
testl %eax, %eax
jne 0x1b389
jmp 0x1b39b
movzbl 0x1(%r14), %ecx
cmpq $0x9, %rcx
ja 0x1b389
incq %r14
movq (%rbx,%rcx,8), %rax
movq (%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1187e
jmp 0x1b396
movsbl %al, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1187e
incq %r14
jmp 0x1b359
leaq 0x47a2(%rip), %rdi      # 0x1fb44
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1187e
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: releasetmp
static void releasetmp(Node p) {
    if (!p) return;
    assert(p->count!=0);
    p->count--;
    switch(generic(p->op)) {
        case ADDRG: case ADDRL: case ADDRF: case CNST:
            if (optimizelevel>0) return;
            break;
        case INDIR:
            if (p->x.optimized) return;
    }
    if (p->count==0) {
        int i;
        for (i=0;i<32;i++) {
            if (p->x.result == temp[i])   busy &= ~(1<<i);
            if (p->x.result==flt_temp[i]) busy_flt &= ~(1<<i);
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1d011
movzwl 0x4(%rdi), %eax
testw %ax, %ax
je 0x1d026
decl %eax
movw %ax, 0x4(%rdi)
movl (%rdi), %ecx
andl $-0x10, %ecx
leal -0x100(%rcx), %edx
cmpl $0x20, %edx
ja 0x1cfa9
movabsq $0x100010001, %rsi      # imm = 0x100010001
btq %rdx, %rsi
jb 0x1cfb3
cmpl $0x40, %ecx
je 0x1d012
cmpl $0x10, %ecx
jne 0x1d01f
testw %ax, %ax
jne 0x1d011
cmpl $0x0, 0xc809(%rip)      # 0x297c8
jg 0x1d011
movq 0x48(%rdi), %rax
movl 0x156d1(%rip), %ecx     # 0x3269c
movl 0x156d3(%rip), %edx     # 0x326a4
xorl %esi, %esi
leaq 0x154b6(%rip), %rdi     # 0x32490
leaq 0x155af(%rip), %r8      # 0x32590
xorl %r9d, %r9d
cmpq (%rsi,%rdi), %rax
jne 0x1cff4
btrl %r9d, %ecx
movl %ecx, 0x156a8(%rip)     # 0x3269c
cmpq (%rsi,%r8), %rax
jne 0x1d004
btrl %r9d, %edx
movl %edx, 0x156a0(%rip)     # 0x326a4
incq %r9
addq $0x8, %rsi
cmpq $0x20, %r9
jne 0x1cfe4
retq
testw %ax, %ax
jne 0x1d011
cmpb $0x0, 0x60(%rdi)
je 0x1cfc1
jmp 0x1d011
testw %ax, %ax
jne 0x1d011
jmp 0x1cfc1
pushq %rax
leaq 0x5124(%rip), %rdi      # 0x22152
leaq 0x4f11(%rip), %rsi      # 0x21f46
leaq 0x5122(%rip), %rcx      # 0x2215e
movl $0x199, %edx            # imm = 0x199
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: dereference
static char dereference(char adrmode)
{
    switch (adrmode) {
        case 'C': return 'D';
        case 'R': return 'Z';
        case 'A': return 'Y';
        case 'Z': return 'I';
        default:
            assert(is_dereferenceable(adrmode));
            return 0;
    }

}

// Assembly:
cmpl $0x51, %edi
jg 0x1d058
cmpl $0x41, %edi
je 0x1d065
movb $0x44, %al
cmpl $0x43, %edi
jne 0x1d06b
retq
cmpl $0x5a, %edi
je 0x1d068
cmpl $0x52, %edi
jne 0x1d06b
movb $0x5a, %al
retq
movb $0x59, %al
retq
movb $0x49, %al
retq
pushq %rax
leaq 0x5101(%rip), %rdi      # 0x22174
leaq 0x4ecc(%rip), %rsi      # 0x21f46
leaq 0x510f(%rip), %rcx      # 0x22190
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: binary
static void binary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
    else
        print("\t%s_%c%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc728(%rip)      # 0x297c8
movq 0x15609(%rip), %rdi     # 0x326b0
je 0x1d0c3
movzbl 0x40(%rdi), %eax
cmpl $0x49, %eax
je 0x1d115
cmpl $0x5a, %eax
je 0x1d10e
cmpl $0x52, %eax
jne 0x1d11c
movl $0x43, %ebp
jmp 0x1d11f
callq 0x1d2ca
movq %rax, %r14
movq 0x155e6(%rip), %rdi     # 0x326b8
callq 0x1d2ca
movq %rax, %r15
movq 0x155df(%rip), %rdi     # 0x326c0
callq 0x1d2ca
leaq 0x5440(%rip), %rdi      # 0x2252d
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1187e
movl $0x44, %ebp
jmp 0x1d11f
movl $0x59, %ebp
jmp 0x1d11f
movsbl %al, %ebp
movq 0x15592(%rip), %rax     # 0x326b8
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1d149
cmpl $0x5a, %eax
je 0x1d141
cmpl $0x52, %eax
jne 0x1d151
movl $0x43, %r14d
jmp 0x1d155
movl $0x44, %r14d
jmp 0x1d155
movl $0x59, %r14d
jmp 0x1d155
movsbl %al, %r14d
movq 0x15564(%rip), %rax     # 0x326c0
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1d17f
cmpl $0x5a, %eax
je 0x1d177
cmpl $0x52, %eax
jne 0x1d187
movl $0x43, %r15d
jmp 0x1d18b
movl $0x44, %r15d
jmp 0x1d18b
movl $0x59, %r15d
jmp 0x1d18b
movsbl %al, %r15d
callq 0x1d2ca
movq %rax, %r12
movq 0x1551e(%rip), %rdi     # 0x326b8
callq 0x1d2ca
movq %rax, %r13
movq 0x15517(%rip), %rdi     # 0x326c0
callq 0x1d2ca
movq %rax, %r10
leaq 0x5384(%rip), %rdi      # 0x2253c
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r13
callq 0x1187e
addq $0x18, %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/gen.c
// Function: unary
static void unary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(r));
    else
        print("\t%s_%c%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc5d7(%rip)      # 0x297c8
movq 0x154b8(%rip), %rdi     # 0x326b0
je 0x1d214
movzbl 0x40(%rdi), %eax
cmpl $0x49, %eax
je 0x1d250
cmpl $0x5a, %eax
je 0x1d249
cmpl $0x52, %eax
jne 0x1d257
movl $0x43, %ebp
jmp 0x1d25a
callq 0x1d2ca
movq %rax, %r14
movq 0x1549d(%rip), %rdi     # 0x326c0
callq 0x1d2ca
leaq 0x5323(%rip), %rdi      # 0x22552
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1187e
movl $0x44, %ebp
jmp 0x1d25a
movl $0x59, %ebp
jmp 0x1d25a
movsbl %al, %ebp
movq 0x1545f(%rip), %rax     # 0x326c0
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1d284
cmpl $0x5a, %eax
je 0x1d27c
cmpl $0x52, %eax
jne 0x1d28c
movl $0x43, %r14d
jmp 0x1d290
movl $0x44, %r14d
jmp 0x1d290
movl $0x59, %r14d
jmp 0x1d290
movsbl %al, %r14d
callq 0x1d2ca
movq %rax, %r15
movq 0x15421(%rip), %rdi     # 0x326c0
callq 0x1d2ca
leaq 0x52b3(%rip), %rdi      # 0x2255e
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1187e
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: save_busy
static void save_busy(Node p) {
    int i, offset=p->x.argoffset;
    for (i=0; i<8; i++) {
        if (p->x.busy & (1<<i)) {
            // save on stack and increase the argsize
            print("\tSAVE(tmp%d,(sp),%d)\n", i, offset);
            offset += 2;
        }
    }
    // update the CALL's argoffset so that it is passed to the callee
    p->x.argoffset = offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
leaq 0x526f(%rip), %r14      # 0x22576
xorl %r15d, %r15d
movl 0x54(%rbx), %eax
btl %r15d, %eax
jae 0x1d325
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1187e
addl $0x2, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0x1d30a
movl %ebp, 0x50(%rbx)
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/gen.c
// Function: restore_busy
static void restore_busy(Node p) {
    int i, offset=p->x.argoffset;
    for (i=7; i>=0; i--) { // reverse order
        if (p->x.busy & (1<<i)) {
            offset -= 2;
            print("\tRESTORE((sp),%d,tmp%d)\n", offset, i);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
movl $0x7, %r14d
leaq 0x5236(%rip), %r15      # 0x2258c
movl 0x54(%rbx), %eax
btl %r14d, %eax
jae 0x1d371
addl $-0x2, %ebp
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1187e
addl $-0x1, %r14d
jb 0x1d356
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/gen.c
// Function: compare
static void compare(char *inst) {
     if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
    else
        print("\t%s_%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc435(%rip)      # 0x297c8
movq 0x15316(%rip), %rdi     # 0x326b0
je 0x1d3b6
movzbl 0x40(%rdi), %eax
cmpl $0x49, %eax
je 0x1d400
cmpl $0x5a, %eax
je 0x1d3f9
cmpl $0x52, %eax
jne 0x1d407
movl $0x43, %ebp
jmp 0x1d40a
callq 0x1d2ca
movq %rax, %r14
movq 0x152f3(%rip), %rdi     # 0x326b8
callq 0x1d2ca
movq 0x152ef(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %r8
leaq 0x514e(%rip), %rdi      # 0x2252d
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1187e
movl $0x44, %ebp
jmp 0x1d40a
movl $0x59, %ebp
jmp 0x1d40a
movsbl %al, %ebp
movq 0x152a7(%rip), %rax     # 0x326b8
movzbl 0x40(%rax), %eax
cmpl $0x49, %eax
je 0x1d434
cmpl $0x5a, %eax
je 0x1d42c
cmpl $0x52, %eax
jne 0x1d43c
movl $0x43, %r14d
jmp 0x1d440
movl $0x44, %r14d
jmp 0x1d440
movl $0x59, %r14d
jmp 0x1d440
movsbl %al, %r14d
callq 0x1d2ca
movq %rax, %r15
movq 0x15269(%rip), %rdi     # 0x326b8
callq 0x1d2ca
movq 0x15265(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rsp)
leaq 0x5138(%rip), %rdi      # 0x225a5
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x1187e
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/gen.c
// Function: compare0
static void compare0(char *inst) {
    print("\t%s_%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,output_arg(a)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15216(%rip), %rdi     # 0x326b0
movzbl 0x40(%rdi), %eax
cmpl $0x49, %eax
je 0x1d4bb
cmpl $0x5a, %eax
je 0x1d4b4
cmpl $0x52, %eax
jne 0x1d4c2
movl $0x43, %ebp
jmp 0x1d4c5
movl $0x44, %ebp
jmp 0x1d4c5
movl $0x59, %ebp
jmp 0x1d4c5
movsbl %al, %ebp
callq 0x1d2ca
movq 0x151ef(%rip), %rcx     # 0x326c0
movq 0x8(%rcx), %rcx
movq (%rcx), %r8
leaq 0x52be(%rip), %rdi      # 0x2279d
movq %rbx, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1187e
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/token.c
// Function: SH_Token__init
SH_Token*
SH_Token__init(sh_char_t* value, size_t n, int* err) {
	SH_Token* obj;
	sh_char_t* ptr;
	sh_char_t  c;
	size_t m;

	__cascade(err, (SH_Token*)0);

	if (n < 1 || n > SH_TOKEN_LENGTH_MAX) {
		__raise(err, SH_E_TOKEN_TOO_LONG);
		return (SH_Token*)0;
	}

	c = *value;
	if (!LEGIT_START(c)) {
		__raise(err, SH_E_TOKEN_BAD_CHAR);
		return (SH_Token*)0;
	}

	ptr = value;
	m = 0;
	while (m < n) {
		c = *ptr;
		if (LEGIT(c)) {
			ptr++;
			m++;
		} else {
			__raise(err, SH_E_TOKEN_BAD_CHAR);
			return (SH_Token*)0;
		}
	}

	obj = (SH_Token*)malloc(sizeof(SH_Token));
	if ((SH_Token*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Token*)0;
	}

	obj->value = (sh_char_t*)malloc(sizeof(sh_char_t) * (m + 1));
	if ((sh_char_t*)0 == obj->value) {
		free(obj);
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Token*)0;
	}

	memcpy((void*)obj->value, (const void*)value, m);
	obj->value[m] = SH_CHAR_C(0);
	obj->length = m;

	__clear(err);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1150
cmpl $0x0, (%rbx)
je 0x1150
xorl %r12d, %r12d
jmp 0x11e3
movq $-0x201, %rax           # imm = 0xFDFF
leaq (%r14,%rax), %rcx
cmpq %rax, %rcx
ja 0x1167
movl $0x140001, %eax         # imm = 0x140001
jmp 0x11d9
movzbl (%r15), %eax
cmpq $0x40, %rax
jb 0x118a
movl $0xffffffc0, %ecx       # imm = 0xFFFFFFC0
addl %ecx, %eax
movabsq $0x7fffffe07fffffe, %rcx # imm = 0x7FFFFFE07FFFFFE
btq %rax, %rcx
jb 0x118f
jmp 0x11d4
cmpl $0x2a, %eax
jne 0x11d4
testq %r14, %r14
je 0x11f0
movl $0xffffffc0, %eax       # imm = 0xFFFFFFC0
xorl %ecx, %ecx
movabsq $0x57ffffffc7fffffe, %rdx # imm = 0x57FFFFFFC7FFFFFE
movabsq $0x7ffecfa00000000, %rsi # imm = 0x7FFECFA00000000
movzbl (%r15,%rcx), %edi
cmpq $0x40, %rdi
jb 0x11c4
addl %eax, %edi
btq %rdi, %rdx
jb 0x11ca
jmp 0x11d4
btq %rdi, %rsi
jae 0x11d4
incq %rcx
cmpq %rcx, %r14
jne 0x11af
jmp 0x11f3
movl $0x140002, %eax         # imm = 0x140002
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x11e3
movl %eax, (%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x1050
testq %rax, %rax
je 0x1237
movq %rax, %r12
leaq 0x1(%r14), %rdi
callq 0x1050
movq %rax, (%r12)
testq %rax, %rax
je 0x123e
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1040
xorl %eax, %eax
movb $0x0, (%r13,%r14)
movq %r14, 0x8(%r12)
jmp 0x11dc
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x11d9
movq %r12, %rdi
callq 0x1030
xorl %r12d, %r12d
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x11dc
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]unix-samples/chapter1/fork2.c
// Function: decode_status
void 
decode_status(int status)
{
	if (WIFEXITED(status)) {
		int rc = WEXITSTATUS(status);
		if (rc == 0)
			return;
		else {
			fprintf(stderr, "Child exited with exit(%d)\n", rc);
			exit(1);
		}
	} else if (WIFSIGNALED(status)) {
		int sig = WTERMSIG(status);
		fprintf(stderr, "Child exited with signal %d (%s)\n", 
		    sig, strsignal(sig));
	} else {
		// under normal circumstances, you either get a signal
		// or an exit status
		fprintf(stderr, "This should never happen: %d\n", status);
	}
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %edx
movl %edi, %ebx
andl $0x7f, %ebx
jne 0x1204
shrl $0x8, %edx
andl $0xff, %edx
jne 0x123e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %ebx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
movq 0x2de3(%rip), %rcx      # 0x3ff8
movq (%rcx), %r14
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x1245
movl %ebx, %edi
callq 0x1060
leaq 0xe07(%rip), %rsi       # 0x2034
movq %r14, %rdi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1040
jmp 0x1256
movl %edx, %edi
callq 0x10b0
leaq 0xe0a(%rip), %rsi       # 0x2056
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]unix-samples/chapter1/fork2.c
// Function: main
int
main()
{
	int i = 15;
	int pid = fork();
	switch(pid) {
	case -1: 
		err(1, "fork");
	case 0:
		perform_computation(i);
		exit(0);
	}
	// parent
	int status;
	int r = waitpid(pid, &status, 0);
	if (r == -1)
		err(1, "waitpid");
	decode_status(status);
	exit(0);
}

// Assembly:
pushq %rax
callq 0x1090
testl %eax, %eax
je 0x1278
cmpl $-0x1, %eax
jne 0x1284
leaq 0xdfe(%rip), %rsi       # 0x2074
jmp 0x129e
movl $0xf, %edi
callq 0x11cc
jmp 0x12b3
leaq 0x4(%rsp), %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x1070
cmpl $-0x1, %eax
jne 0x12aa
leaq 0xddb(%rip), %rsi       # 0x2079
movl $0x1, %edi
xorl %eax, %eax
callq 0x1050
movl 0x4(%rsp), %edi
callq 0x11e4
xorl %edi, %edi
callq 0x1080