LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x29b93
jmp 0x29b82
movl -0x2c(%rbp), %eax
subl $0xd, %eax
je 0x29c5d
jmp 0x29cf4
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %r8d
leaq 0x90c7(%rip), %rsi      # 0x32c7e
movb $0x0, %al
callq 0x1a630
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29c47
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x90a2(%rip), %rsi      # 0x32c8f
movb $0x0, %al
callq 0x1a630
movq -0x18(%rbp), %rax
cmpw $0x0, 0x16(%rax)
je 0x29c20
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movswl 0x14(%rax), %edx
movq -0x18(%rbp), %rax
movswl 0x16(%rax), %ecx
leaq 0x908a(%rip), %rsi      # 0x32ca3
movb $0x0, %al
callq 0x1a630
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x907e(%rip), %rsi      # 0x32cb0
movb $0x0, %al
callq 0x1a630
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29bce
movl -0xc(%rbp), %edi
leaq 0x72b0(%rip), %rsi      # 0x30f01
movb $0x0, %al
callq 0x1a630
jmp 0x29d09
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x9046(%rip), %rsi      # 0x32cb9
movb $0x0, %al
callq 0x1a630
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x29ce1
cmpl $0x0, -0x1c(%rbp)
jle 0x29cb6
movl -0xc(%rbp), %edi
leaq 0x7275(%rip), %rsi      # 0x30f24
movb $0x0, %al
callq 0x1a630
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rax
movl 0x48(%rax), %ecx
leaq 0x8ff4(%rip), %rsi      # 0x32cc3
movb $0x0, %al
callq 0x1a630
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29c81
movl -0xc(%rbp), %edi
leaq 0x7216(%rip), %rsi      # 0x30f01
movb $0x0, %al
callq 0x1a630
jmp 0x29d09
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rdx
leaq 0x8fc7(%rip), %rsi      # 0x32cc9
movb $0x0, %al
callq 0x1a630
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl 0x1a57e(%rip), %eax     # 0x44298
leaq 0x1726f(%rip), %rcx     # 0x40f90
cmpl (%rcx), %eax
jl 0x29e23
movl $0x0, 0x1a565(%rip)     # 0x44298
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x80, %rax
jae 0x29e21
movslq -0x4(%rbp), %rcx
leaq 0x1a54b(%rip), %rax     # 0x442a0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29e11
movq -0x10(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x29d8d
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x29dff
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x29dc0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzwl 0x18(%rax), %eax
leaq 0x171e5(%rip), %rcx     # 0x40f90
cmpl (%rcx), %eax
jne 0x29dc0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x29dfd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x29df1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzwl 0x18(%rax), %eax
cmpl 0x1a4bb(%rip), %eax     # 0x44298
jle 0x29df1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzwl 0x18(%rax), %eax
movl %eax, 0x1a4a7(%rip)     # 0x44298
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x29dff
jmp 0x29e01
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x29d6b
jmp 0x29e13
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x29d3a
jmp 0x29e23
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1e, %eax
ja 0x29e9b
movq -0x18(%rbp), %rax
leaq 0x876e(%rip), %rcx      # 0x325c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x29e30
movl %eax, -0x4(%rbp)
jmp 0x29eba
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x29eba
movl $0x7, -0x4(%rbp)
jmp 0x29eba
movl $0x9, -0x4(%rbp)
jmp 0x29eba
movl $0x5, -0x4(%rbp)
jmp 0x29eba
leaq 0x5235(%rip), %rdi      # 0x2f0d7
leaq 0x87d7(%rip), %rsi      # 0x32680
movl $0x26c, %edx            # imm = 0x26C
leaq 0x8e4f(%rip), %rcx      # 0x32d04
callq 0x30c0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
jb 0x29eef
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29ef7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x29f6c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x29f6c
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x29f32
jmp 0x29f27
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29f12
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x21(%rbp)
jle 0x29f5f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x1a2e7(%rip), %rax     # 0x44240
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x29f73
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a48b
jmp 0x2a58b
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl $0x1, %eax
jne 0x2a4e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x2a4db
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x2a4db
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x20, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x24, 0x1(%rax)
jmp 0x2a583
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x51, %eax
jne 0x2a522
movq 0x1a1ac(%rip), %rax     # 0x446a0
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x24d90
movq -0x10(%rbp), %rsi
movl %eax, %edx
leaq 0x9cb4(%rip), %rdi      # 0x341c3
movb $0x0, %al
callq 0x1afc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2a581
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2a55f
movq 0x1a163(%rip), %rsi     # 0x446a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x9c7d(%rip), %rdi      # 0x341c9
movb $0x0, %al
callq 0x1afc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2a57f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x9c61(%rip), %rdi      # 0x341cf
movb $0x0, %al
callq 0x1afc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2a581
jmp 0x2a583
movq -0x8(%rbp), %rax
movb $0x43, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
testb $0x1, 0x19e62(%rip)     # 0x446a8
je 0x2a84d
jmp 0x2a911
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x2a8f2
movq -0x18(%rbp), %rax
leaq 0x854c(%rip), %rcx      # 0x32db8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl -0x8(%rbp), %esi
leaq 0x9965(%rip), %rdi      # 0x341e5
movb $0x0, %al
callq 0x1a890
jmp 0x2a911
movzwl -0x8(%rbp), %esi
leaq 0x994e(%rip), %rdi      # 0x341e5
movb $0x0, %al
callq 0x1a890
jmp 0x2a911
movl -0x8(%rbp), %esi
leaq 0x9944(%rip), %rdi      # 0x341ee
movb $0x0, %al
callq 0x1a890
jmp 0x2a911
movl -0x8(%rbp), %esi
leaq 0x993a(%rip), %rdi      # 0x341f7
movb $0x0, %al
callq 0x1a890
jmp 0x2a911
movq -0x8(%rbp), %rsi
leaq 0x9926(%rip), %rdi      # 0x341f7
movb $0x0, %al
callq 0x1a890
jmp 0x2a911
movsd -0x8(%rbp), %xmm0
callq 0x2a600
jmp 0x2a911
movsd -0x8(%rbp), %xmm0
callq 0x2a600
jmp 0x2a911
leaq 0x47de(%rip), %rdi      # 0x2f0d7
leaq 0x9901(%rip), %rsi      # 0x34201
movl $0x122, %edx            # imm = 0x122
leaq 0x9902(%rip), %rcx      # 0x3420e
callq 0x30c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0x19d72(%rip)     # 0x446a8
je 0x2a93a
jmp 0x2a96d
jmp 0x2a93c
cmpl $0x0, -0x4(%rbp)
jle 0x2a96d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %esi
leaq 0x9880(%rip), %rdi      # 0x341db
movb $0x0, %al
callq 0x1a890
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2a93c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpl $0x8, 0x19ef1(%rip)     # 0x448f0
je 0x2aa0f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x5, 0x8(%rax)
jne 0x2aa18
movl $0x0, -0x4(%rbp)
jmp 0x2aa4f
movslq 0x19ed1(%rip), %rcx     # 0x448f0
leaq 0x19c8a(%rip), %rax     # 0x446b0
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x52, 0x8(%rax)
movl 0x19eb1(%rip), %eax     # 0x448f0
addl $0x1, %eax
movl %eax, 0x19ea8(%rip)     # 0x448f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x10b31(%rip)     # 0x3b924
jle 0x2ae12
movq -0x8(%rbp), %rax
movzbl 0x1a(%rax), %eax
cmpl $0x4e, %eax
jne 0x2ae12
movq -0x8(%rbp), %rdi
callq 0x2a9f0
cmpl $0x0, %eax
je 0x2ae12
jmp 0x2ae86
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2ae2d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x2ae2d
jmp 0x2ae86
movb 0x19875(%rip), %cl      # 0x446a8
leaq 0x9467(%rip), %rdi      # 0x342a1
leaq 0x9456(%rip), %rax      # 0x34297
testb $0x1, %cl
cmovneq %rax, %rdi
movl 0x19aaa(%rip), %esi     # 0x448f8
movb $0x0, %al
callq 0x1afc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x41, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x43, 0x1a(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %eax
addl 0x19a78(%rip), %eax     # 0x448f8
movl %eax, 0x19a72(%rip)     # 0x448f8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: gen
Node gen(Node p) {
    Node head, *last;
    for (last = &head; p; p = p->link)
        last = linearize(p, last, 0);
    for (p = head; p; p = p->x.next) {
        if (graph_output) print_graph_node(p);
        else tmpalloc(p);
    }
    return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2afee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2b040
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2afc4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2b02a
testb $0x1, 0x196a4(%rip)     # 0x446a8
je 0x2b011
movq -0x8(%rbp), %rdi
callq 0x2b170
jmp 0x2b01a
movq -0x8(%rbp), %rdi
callq 0x2b630
jmp 0x2b01c
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2aff6
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b14f
movq -0x10(%rbp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2b14f
cmpl $0x0, 0x108b0(%rip)     # 0x3b924
jle 0x2b0fa
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x24(%rbp)
subl $0x10, %eax
je 0x2b0b1
jmp 0x2b08d
movl -0x24(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x2b0b1
jmp 0x2b099
movl -0x24(%rbp), %eax
subl $0x110, %eax            # imm = 0x110
je 0x2b0b1
jmp 0x2b0a5
movl -0x24(%rbp), %eax
subl $0x120, %eax            # imm = 0x120
jne 0x2b0f8
jmp 0x2b0b1
movq -0x10(%rbp), %rax
movb $0x1, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b162
jmp 0x2b0fa
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2b040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2b040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x61(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x38, %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2b868
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x2b840
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jl 0x2b840
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x9, %eax
jg 0x2b840
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
leaq 0x7537(%rip), %rdi      # 0x32d6e
movb $0x0, %al
callq 0x1a890
jmp 0x2b855
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
leaq 0x6af4(%rip), %rdi      # 0x32342
movb $0x0, %al
callq 0x1a890
jmp 0x2b857
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2b7e0
leaq 0x52cd(%rip), %rdi      # 0x30b3c
movb $0x0, %al
callq 0x1a890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: emit
void emit(Node p) {
    if (graph_output) return;
    for (; p; p=p->x.next)
        if (optimizelevel==0) emitdag0(p);
        else emitdag(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x18e15(%rip)     # 0x446a8
je 0x2b897
jmp 0x2b8cd
jmp 0x2b899
cmpq $0x0, -0x8(%rbp)
je 0x2b8cd
cmpl $0x0, 0x1007d(%rip)     # 0x3b924
jne 0x2b8b4
movq -0x8(%rbp), %rdi
callq 0x2b8e0
jmp 0x2b8bd
movq -0x8(%rbp), %rdi
callq 0x2c520
jmp 0x2b8bf
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b899
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d3c8
jmp 0x2d4f8
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x2d3d7
jmp 0x2d3f6
leaq 0x702f(%rip), %rdi      # 0x3440d
leaq 0x6e1c(%rip), %rsi      # 0x34201
movl $0x199, %edx            # imm = 0x199
leaq 0x7028(%rip), %rcx      # 0x34419
callq 0x30c0
movq -0x8(%rbp), %rax
movw 0x4(%rax), %cx
decw %cx
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $-0x10, %eax
movl %eax, -0x10(%rbp)
subl $0x10, %eax
je 0x2d446
jmp 0x2d418
movl -0x10(%rbp), %eax
subl $0x40, %eax
je 0x2d456
jmp 0x2d422
movl -0x10(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x2d446
jmp 0x2d42e
movl -0x10(%rbp), %eax
subl $0x110, %eax            # imm = 0x110
je 0x2d446
jmp 0x2d43a
movl -0x10(%rbp), %eax
subl $0x120, %eax            # imm = 0x120
jne 0x2d467
jmp 0x2d446
cmpl $0x0, 0xe4d7(%rip)      # 0x3b924
jle 0x2d454
jmp 0x2d4f8
jmp 0x2d467
movq -0x8(%rbp), %rax
cmpb $0x0, 0x60(%rax)
je 0x2d465
jmp 0x2d4f8
jmp 0x2d467
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x2d4f8
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x2d4f6
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rdx
leaq 0x17258(%rip), %rcx     # 0x446f0
cmpq (%rcx,%rdx,8), %rax
jne 0x2d4b7
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl 0x1744f(%rip), %eax     # 0x44900
movl %eax, 0x17449(%rip)     # 0x44900
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rdx
leaq 0x17326(%rip), %rcx     # 0x447f0
cmpq (%rcx,%rdx,8), %rax
jne 0x2d4e9
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl 0x17425(%rip), %eax     # 0x44908
movl %eax, 0x1741f(%rip)     # 0x44908
jmp 0x2d4eb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d47f
jmp 0x2d4f8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: is_temporary
static bool is_temporary(Symbol s) {
    int i;
    for (i=0;i<32;i++)
        if (s==temp[i]) return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x2d53d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0x171cc(%rip), %rcx     # 0x446f0
cmpq (%rcx,%rdx,8), %rax
jne 0x2d530
movb $0x1, -0x1(%rbp)
jmp 0x2d541
jmp 0x2d532
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2d50f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x19, %eax
ja 0x2d5ec
movq -0x10(%rbp), %rax
leaq 0x6a39(%rip), %rcx      # 0x34004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x44, -0x1(%rbp)
jmp 0x2d620
movb $0x5a, -0x1(%rbp)
jmp 0x2d620
movb $0x59, -0x1(%rbp)
jmp 0x2d620
movb $0x49, -0x1(%rbp)
jmp 0x2d620
movsbl -0x2(%rbp), %edi
callq 0x2d550
testb $0x1, %al
jne 0x2d5fb
jmp 0x2d5fd
jmp 0x2d61c
leaq 0x6e2b(%rip), %rdi      # 0x3442f
leaq 0x6bf6(%rip), %rsi      # 0x34201
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0x6e34(%rip), %rcx      # 0x3444b
callq 0x30c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: gettmp
static void gettmp(Node p) {
    int t;
    if ( optype(p->op)!=F && optype(p->op)!=D ) {
        for (t=0;t<32;t++)
            if ((busy&(1<<t))==0) {
                busy |= 1<<t;
                p->x.result=temp[t];
                p->x.adrmode='Z';

                p->x.name = temp[t]->x.name;
                return;
            }
    } else
        for (t=0;t<32;t++)
            if ((busy_flt&(1<<t))==0) {
                busy_flt |= 1<<t;
                p->x.result=flt_temp[t];
                p->x.adrmode='Y';
                local(flt_temp[t]);
                p->x.name = flt_temp[t]->x.name;
                return;
            }
    perror("Too complex expression"); exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x1, %eax
je 0x2d9ac
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
cmpl $0x2, %eax
je 0x2d9ac
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x2d9a7
movl 0x16fcd(%rip), %eax     # 0x44900
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x2d99a
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl 0x16faa(%rip), %eax     # 0x44900
movl %eax, 0x16fa4(%rip)     # 0x44900
movslq -0xc(%rbp), %rcx
leaq 0x16d89(%rip), %rax     # 0x446f0
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movb $0x5a, 0x40(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x16d6a(%rip), %rax     # 0x446f0
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x2da63
jmp 0x2d99c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d927
jmp 0x2da4d
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x2da4b
movl 0x16f45(%rip), %eax     # 0x44908
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x2da3b
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl 0x16f22(%rip), %eax     # 0x44908
movl %eax, 0x16f1c(%rip)     # 0x44908
movslq -0xc(%rbp), %rcx
leaq 0x16df9(%rip), %rax     # 0x447f0
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movb $0x59, 0x40(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x16dda(%rip), %rax     # 0x447f0
movq (%rax,%rcx,8), %rdi
callq 0x2ade0
movslq -0xc(%rbp), %rcx
leaq 0x16dc6(%rip), %rax     # 0x447f0
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x2da63
jmp 0x2da3d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d9b3
jmp 0x2da4d
leaq 0x6a31(%rip), %rdi      # 0x34485
callq 0x3150
movl $0x1, %edi
callq 0x3180
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xdea1(%rip)      # 0x3b924
jne 0x2dadb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x16e7c(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x18(%rbp)
movq 0x16e74(%rip), %rdi     # 0x44918
callq 0x2dc60
movq %rax, -0x10(%rbp)
movq 0x16e6c(%rip), %rdi     # 0x44920
callq 0x2dc60
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rax, %r8
leaq 0x6d19(%rip), %rdi      # 0x347e8
movb $0x0, %al
callq 0x1a890
jmp 0x2db7e
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x16e26(%rip), %rax     # 0x44910
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x3c(%rbp)
movq 0x16e18(%rip), %rax     # 0x44918
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x38(%rbp)
movq 0x16e0a(%rip), %rax     # 0x44920
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x34(%rbp)
movq 0x16de4(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x30(%rbp)
movq 0x16ddc(%rip), %rdi     # 0x44918
callq 0x2dc60
movq %rax, -0x28(%rbp)
movq 0x16dd4(%rip), %rdi     # 0x44920
callq 0x2dc60
movq -0x48(%rbp), %rsi
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x34(%rbp), %r8d
movq -0x30(%rbp), %r9
movq -0x28(%rbp), %r10
leaq 0x6c89(%rip), %rdi      # 0x347f7
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1a890
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xdd81(%rip)      # 0x3b924
jne 0x2dbe4
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16d5c(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x10(%rbp)
movq 0x16d5c(%rip), %rdi     # 0x44920
callq 0x2dc60
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rax, %rcx
leaq 0x6c32(%rip), %rdi      # 0x3480d
movb $0x0, %al
callq 0x1a890
jmp 0x2dc53
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x16d1d(%rip), %rax     # 0x44910
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x28(%rbp)
movq 0x16d17(%rip), %rax     # 0x44920
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x24(%rbp)
movq 0x16cf1(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x20(%rbp)
movq 0x16cf1(%rip), %rdi     # 0x44920
callq 0x2dc60
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
movq %rax, %r9
leaq 0x6bcd(%rip), %rdi      # 0x34819
movb $0x0, %al
callq 0x1a890
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x2dd87
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2dd7a
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x6ac7(%rip), %rdi      # 0x34831
movb $0x0, %al
callq 0x1a890
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x2dd7c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2dd3d
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: simple_adrmode
static char simple_adrmode(char adrmode) {
    if (adrmode=='Z') return 'D';
    else if (adrmode=='R') return 'C';
    else if (adrmode=='I') return 'Y';
    else return adrmode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x5a, %eax
jne 0x2ddb9
movb $0x44, -0x1(%rbp)
jmp 0x2dddd
movsbl -0x2(%rbp), %eax
cmpl $0x52, %eax
jne 0x2ddc8
movb $0x43, -0x1(%rbp)
jmp 0x2dddd
movsbl -0x2(%rbp), %eax
cmpl $0x49, %eax
jne 0x2ddd7
movb $0x59, -0x1(%rbp)
jmp 0x2dddd
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x7, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x2de57
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2de4a
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x6a04(%rip), %rdi      # 0x34847
movb $0x0, %al
callq 0x1a890
jmp 0x2de4c
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2de0d
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xdab1(%rip)      # 0x3b924
jne 0x2dec5
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16a8c(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x10(%rbp)
movq 0x16a84(%rip), %rdi     # 0x44918
callq 0x2dc60
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rax, %rcx
movq 0x16a75(%rip), %rax     # 0x44920
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x692f(%rip), %rdi      # 0x347e8
movb $0x0, %al
callq 0x1a890
jmp 0x2df46
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x16a3c(%rip), %rax     # 0x44910
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x28(%rbp)
movq 0x16a2e(%rip), %rax     # 0x44918
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0x24(%rbp)
movq 0x16a10(%rip), %rdi     # 0x44910
callq 0x2dc60
movq %rax, -0x20(%rbp)
movq 0x16a08(%rip), %rdi     # 0x44918
callq 0x2dc60
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
movq %rax, %r9
movq 0x169f3(%rip), %rax     # 0x44920
movq 0x8(%rax), %rax
movq (%rax), %rax
leaq 0x6925(%rip), %rdi      # 0x34860
movq %rax, (%rsp)
movb $0x0, %al
callq 0x1a890
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16965(%rip), %rax     # 0x44910
movsbl 0x40(%rax), %edi
callq 0x2dda0
movsbl %al, %eax
movl %eax, -0xc(%rbp)
movq 0x1694f(%rip), %rdi     # 0x44910
callq 0x2dc60
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movq %rax, %rcx
movq 0x16949(%rip), %rax     # 0x44920
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x6a99(%rip), %rdi      # 0x34a7e
movb $0x0, %al
callq 0x1a890
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x1225
movl -0x4(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1200
addq $0x20, %rsp
popq %rbp
retq
movq 0x2df1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0xe04(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1080
movl -0x4(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1277
movl -0x4(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0xc(%rbp)
movq 0x2db0(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x1060
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %edx
movq %rax, %rcx
leaq 0xdc6(%rip), %rsi       # 0x2034
movb $0x0, %al
callq 0x1040
jmp 0x1292
movq 0x2d7a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0xdcb(%rip), %rsi       # 0x2056
movb $0x0, %al
callq 0x1040
jmp 0x1294
movl $0x1, %edi
callq 0x1080
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0xf, -0x8(%rbp)
callq 0x1090
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $-0x1, %eax
je 0x12d4
jmp 0x12cb
movl -0x18(%rbp), %eax
testl %eax, %eax
je 0x12e7
jmp 0x12f6
movl $0x1, %edi
leaq 0xd94(%rip), %rsi       # 0x2074
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %edi
callq 0x11a0
xorl %edi, %edi
callq 0x1080
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1070
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1320
movl $0x1, %edi
leaq 0xd60(%rip), %rsi       # 0x2079
movb $0x0, %al
callq 0x1050
movl -0x10(%rbp), %edi
callq 0x11d0
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_align.c
// Function: print_array
static void print_array(
        const char * filename,
        int * array,
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        parasail_result_t *result)
{
    if ((result->flag & PARASAIL_FLAG_TRACE)
            && ((result->flag & PARASAIL_FLAG_STRIPED)
                || (result->flag & PARASAIL_FLAG_SCAN))) {
        int *array_ = parasail_striped_unwind(s1Len, s2Len, result, array);
        print_array_int(filename, array_, s1, s1Len, s2, s2Len, result);
        free(array_);
    }
    else if (result->flag & PARASAIL_FLAG_TRACE) {
        print_array_int8_t(filename, (int8_t*)array, s1, s1Len, s2, s2Len, result);
    }
    else {
        print_array_int(filename, array, s1, s1Len, s2, s2Len, result);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x1f366c
movq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1f3626
movq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x1f366c
movl -0x1c(%rbp), %edi
movl -0x2c(%rbp), %esi
movq 0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x2cb7b0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1f3960
movq -0x38(%rbp), %rdi
callq 0x1f01a0
jmp 0x1f36c9
movq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x1f36a3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1f3b10
jmp 0x1f36c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1f3960
jmp 0x1f36c9
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_close
void parasail_close(parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_close: NULL file\n");
        return;
    }
#if defined(HAVE_SYS_MMAN_H)
    if (-1 == munmap((void*)pf->buf, pf->size)) {
        perror("munmap");
        fprintf(stderr, "parasail_close: cannot munmap file buffer\n");
    }
    if (-1 == close(pf->fd)) {
        perror("close");
        fprintf(stderr, "parasail_close: cannot close file descriptor\n");
    }
#else
    free((void*)pf->buf);
    /* file was already closed */
#endif
    free(pf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x1f4351
movq 0xc2dc9d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d862(%rip), %rsi    # 0xd01ba7
movb $0x0, %al
callq 0x1f01f0
jmp 0x1f43d8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f00c0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x1f4395
leaq 0xb0d84a(%rip), %rdi    # 0xd01bc2
callq 0x1f0120
movq 0xc2dc54(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d83b(%rip), %rsi    # 0xd01bc9
movb $0x0, %al
callq 0x1f01f0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1f0290
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x1f43cf
leaq 0xb0d842(%rip), %rdi    # 0xd01bf4
callq 0x1f0120
movq 0xc2dc1a(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d832(%rip), %rsi    # 0xd01bfa
movb $0x0, %al
callq 0x1f01f0
movq -0x8(%rbp), %rdi
callq 0x1f01a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fasta
int parasail_is_fasta(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_is_fasta: NULL pointer\n");
        return -1;
    }

    return parasail_is_fasta_buffer(pf->buf, pf->size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f4415
movq 0xc2dbdd(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d823(%rip), %rsi    # 0xd01c28
movb $0x0, %al
callq 0x1f01f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f442d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f4440
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fasta_buffer
int parasail_is_fasta_buffer(const char *buf, off_t UNUSED(size))
{
    if (NULL == buf) {
        fprintf(stderr, "parasail_is_fasta_buffer: NULL pointer\n");
        return -1;
    }

    return '>' == buf[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f4479
movq 0xc2db79(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d7e0(%rip), %rsi    # 0xd01c49
movb $0x0, %al
callq 0x1f01f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f4492
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x3e, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fastq
int parasail_is_fastq(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_is_fastq: NULL pointer\n");
        return -1;
    }

    return parasail_is_fastq_buffer(pf->buf, pf->size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f44d5
movq 0xc2db1d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d7ac(%rip), %rsi    # 0xd01c71
movb $0x0, %al
callq 0x1f01f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f44ed
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f4500
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_is_fastq_buffer
int parasail_is_fastq_buffer(const char *buf, off_t UNUSED(size))
{
    if (NULL == buf) {
        fprintf(stderr, "parasail_is_fastq_buffer: NULL pointer\n");
        return -1;
    }

    return '@' == buf[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f4539
movq 0xc2dab9(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d769(%rip), %rsi    # 0xd01c92
movb $0x0, %al
callq 0x1f01f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f4552
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)