LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: fillglobls
void
fillglobls(Stab *st, Htab *globls)
{
	size_t i, j, nk, nns;
	void **k, **ns;
	Stab *stab;
	Node *s;

	k = htkeys(st->dcl, &nk);
	for (i = 0; i < nk; i++) {
		s = htget(st->dcl, k[i]);
		if (isconstfn(s))
			s->decl.type = codetype(s->decl.type);
		htput(globls, s, asmname(s));
	}
	free(k);

	ns = htkeys(file.ns, &nns);
	for (j = 0; j < nns; j++) {
		stab = htget(file.ns, ns[j]);
		k = htkeys(stab->dcl, &nk);
		for (i = 0; i < nk; i++) {
			s = htget(stab->dcl, k[i]);
			htput(globls, s, asmname(s));
		}
		free(k);
	}
	free(ns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r15
xorl %r13d, %r13d
cmpq (%rsp), %r13
jae 0x4e22
movq 0x18(%r14), %rdi
movq (%r15,%r13,8), %rsi
callq 0x2a3e8
movq %rax, %r12
movq %rax, %rdi
callq 0x25902
testl %eax, %eax
je 0x4e07
movq 0x28(%r12), %rdi
callq 0x4edb
movq %rax, 0x28(%r12)
movq %r12, %rdi
callq 0x4f1a
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2a22a
incq %r13
jmp 0x4dd6
movq %r15, %rdi
callq 0x4040
leaq 0x59447(%rip), %rax     # 0x5e278
movq 0xa0(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a529
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
cmpq 0x10(%rsp), %r15
jae 0x4ec2
leaq 0x59420(%rip), %rax     # 0x5e278
movq 0xa0(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rsi
callq 0x2a3e8
movq %rax, %r12
movq 0x18(%rax), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r13
xorl %r14d, %r14d
cmpq (%rsp), %r14
jae 0x4eb5
movq 0x18(%r12), %rdi
movq (%r13,%r14,8), %rsi
callq 0x2a3e8
movq %rax, %rbp
movq %rax, %rdi
callq 0x4f1a
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2a22a
incq %r14
jmp 0x4e82
movq %r13, %rdi
callq 0x4040
incq %r15
jmp 0x4e4a
movq 0x8(%rsp), %rdi
callq 0x4040
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: codetype
Type *
codetype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tycode)
		return ft;
	assert(ft->type == Tyfunc);
	ft = tydup(ft);
	ft->type = Tycode;
	return ft;
}

// Assembly:
pushq %rax
callq 0x1fcd8
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x4f0a
cmpl $0x1e, %ecx
je 0x4f18
leaq 0x26337(%rip), %rdi     # 0x2b22b
leaq 0x26343(%rip), %rsi     # 0x2b23e
leaq 0x26342(%rip), %rcx     # 0x2b244
pushq $0x51
popq %rdx
callq 0x4180
movq %rax, %rdi
callq 0x1fe75
movl $0x1e, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: asmname
char *
asmname(Node *dcl)
{
	char buf[1024];
	char *vis, *pf, *ns, *name, *sep;
	Node *n;

	n = dcl->decl.name;
	pf = Symprefix;
	ns = n->name.ns;
	name = n->name.name;
	vis = "";
	sep = "";
	if (asmsyntax == Plan9)
		if (islocal(dcl))
			vis = "<>";
	if (!ns || !ns[0])
		ns = "";
	else
		sep = "$";
	if (name[0] == '.')
		pf = "";

	bprintf(buf, sizeof buf, "%s%s%s%s%s", pf, ns, sep, name, vis);
	return strdup(buf);
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rax
leaq 0x5929f(%rip), %rdx     # 0x5e1c8
leaq 0x28f1a(%rip), %r8      # 0x2de4a
cmpl $0x2, (%rdx)
movq %r8, %r10
jne 0x4f4d
cmpb $0x0, 0x70(%rdi)
jne 0x4f4a
cmpb $0x0, 0x77(%rdi)
jne 0x4f4a
cmpb $0x0, 0x74(%rdi)
je 0x4fb4
movq %r8, %r10
movq 0x20(%rcx), %r11
movq %r8, %r9
testq %rax, %rax
je 0x4f75
cmpb $0x0, (%rax)
leaq 0x28ee7(%rip), %rcx     # 0x2de4a
cmoveq %rcx, %rax
leaq 0x26307(%rip), %r9      # 0x2b275
cmoveq %rcx, %r9
movq %rax, %r8
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
leaq 0x262f3(%rip), %rdx     # 0x2b277
leaq 0x28ebf(%rip), %rcx     # 0x2de4a
movq %rsp, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x2a9bf
popq %rcx
popq %rdx
movq %rbx, %rdi
callq 0x4340
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
leaq 0x2773f(%rip), %r10     # 0x2c6fa
jmp 0x4f4d
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: initconsts
void
initconsts(Htab *globls)
{
	Type *ty;
	Node *name;
	Node *dcl;

	tyintptr = mktype(Zloc, Tyuint64);
	tyword = mktype(Zloc, Tyuint);
	tyvoid = mktype(Zloc, Tyvoid);

	ty = mktyfunc(Zloc, NULL, 0, mktype(Zloc, Tyvoid));
	ty->type = Tycode;
	name = mknsname(Zloc, "_rt", "abort_oob");
	dcl = mkdecl(Zloc, name, ty);
	dcl->decl.isconst = 1;
	dcl->decl.isextern = 1;
	htput(globls, dcl, asmname(dcl));

	abortoob = mkexpr(Zloc, Ovar, name, NULL);
	abortoob->expr.type = ty;
	abortoob->expr.did = dcl->decl.did;
	abortoob->expr.isconst = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xe
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1fdc2
leaq 0x5934c(%rip), %rcx     # 0x5e328
movq %rax, (%rcx)
pushq $0xc
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1fdc2
leaq 0x5933d(%rip), %rcx     # 0x5e330
movq %rax, (%rcx)
pushq $0x1
popq %rbp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %ebp, %esi
callq 0x1fdc2
leaq 0x5932c(%rip), %rcx     # 0x5e338
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %ebp, %esi
callq 0x1fdc2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2028c
movq %rax, %r14
movl $0x1e, (%rax)
leaq 0x261e1(%rip), %rsi     # 0x2b21d
leaq 0x261de(%rip), %rdx     # 0x2b221
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1bd23
movq %rax, %r15
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rsi
movq %r14, %rdx
callq 0x1bd5f
movq %rax, %r12
movb $0x1, %al
movb %al, 0x72(%r12)
movb %al, 0x74(%r12)
movq %r12, %rdi
callq 0x4f1a
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2a22a
pushq $0x33
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
leaq 0x592a0(%rip), %rcx     # 0x5e340
movq %rax, (%rcx)
movq %r14, 0x20(%rax)
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%rax)
movl $0x1, 0x30(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: closuretype
Type *
closuretype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tyfunc)
		return ft;
	assert(ft->type == Tycode);
	ft = tydup(ft);
	ft->type = Tyfunc;
	return ft;
}

// Assembly:
pushq %rax
callq 0x1fcd8
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x50e0
cmpl $0x1e, %ecx
jne 0x50e2
movq %rax, %rdi
callq 0x1fe75
movl $0x13, (%rax)
popq %rcx
retq
leaq 0x2fac4(%rip), %rdi     # 0x34bad
leaq 0x2614e(%rip), %rsi     # 0x2b23e
leaq 0x26164(%rip), %rcx     # 0x2b25b
pushq $0x5d
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: tydescid
char *
tydescid(char *buf, size_t bufsz, Type *ty)
{
	char *sep, *ns;
	char *p, *end;
	size_t i;

	sep = "";
	ns = "";
	p = buf;
	end = buf + bufsz;
	ty = tydedup(ty);
	if (ty->type == Tyname) {
		if (ty->name->name.ns) {
			ns = ty->name->name.ns;
			sep = "$";
		}
		if (ty->vis != Visintern || ty->isimport)
			p += bprintf(p, end - p, "_tydesc$%s%s%s", ns, sep, ty->name->name.name, ty->tid);
		else
			p += bprintf(p, end - p, "_tydesc$%s%s%s$%d", ns, sep, ty->name->name.name, ty->tid);
		for (i = 0; i < ty->narg; i++)
			p += tyidfmt(p, end - p, ty->arg[i]);
	} else {
		if (file.globls->name) {
			ns = file.globls->name;
			sep = "$";
		}
		bprintf(buf, bufsz, "_tydesc%s%s$%d",sep, ns, ty->tid);
	}
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x1fd76
movq %rax, %r14
cmpl $0x1c, (%rax)
jne 0x517c
movq 0x88(%r14), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
leaq 0x28ced(%rip), %rdx     # 0x2de4a
leaq 0x26111(%rip), %r8      # 0x2b275
cmoveq %rdx, %r8
cmoveq %rdx, %rcx
cmpl $0x0, 0x10(%r14)
je 0x51d0
leaq 0x26108(%rip), %rdx     # 0x2b282
jmp 0x51ea
leaq 0x590f5(%rip), %rax     # 0x5e278
movq 0x90(%rax), %rax
movq 0x8(%rax), %r8
testq %r8, %r8
leaq 0x28cb2(%rip), %rax     # 0x2de4a
leaq 0x260d6(%rip), %rcx     # 0x2b275
cmoveq %rax, %rcx
cmoveq %rax, %r8
movl 0x4(%r14), %r9d
leaq 0x260f1(%rip), %rdx     # 0x2b2a3
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2a9bf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpb $0x0, 0x94(%r14)
leaq 0x260b2(%rip), %rsi     # 0x2b291
leaq 0x2609c(%rip), %rdx     # 0x2b282
cmoveq %rsi, %rdx
leaq (%rbx,%r15), %r12
movq 0x20(%rax), %r9
movl 0x4(%r14), %eax
movl %eax, (%rsp)
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2a9bf
movq %rax, %r15
addq %rbx, %r15
cmpq 0x48(%r14), %r13
jae 0x51bf
movq %r12, %rsi
subq %r15, %rsi
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
callq 0x21651
addq %rax, %r15
incq %r13
jmp 0x520f
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gen.c
// Function: gen
void
gen(char *out)
{
	FILE *fd;

	fd = fopen(out, "w");
	if (!fd)
		die("Couldn't open fd %s", out);

	switch (asmsyntax) {
	case Plan9:
		genp9(fd);
		break;
	case Gnugaself:
	case Gnugasmacho:
		gengas(fd);
		break;
	default:
		die("unknown target");  break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x266a5(%rip), %rsi     # 0x2b8e3
callq 0x42e0
testq %rax, %rax
je 0x5268
leaq 0x58f79(%rip), %rcx     # 0x5e1c8
cmpl $0x2, (%rcx)
jae 0x525d
movq %rax, %rdi
popq %rbx
jmp 0x5c2f
jne 0x5279
movq %rax, %rdi
popq %rbx
jmp 0x614c
leaq 0x26043(%rip), %rdi     # 0x2b2b2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1205c
leaq 0x26046(%rip), %rdi     # 0x2b2c6
xorl %eax, %eax
callq 0x1205c
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gengas.c
// Function: printmem
void
printmem(FILE *fd, Loc *l, char spec)
{
	if (l->type == Locmem) {
		if (l->mem.constdisp)
			fprintf(fd, "%ld", l->mem.constdisp);
	} else {
		if (l->mem.lbldisp)
			fprintf(fd, "%s", l->mem.lbldisp);
	}
	if (l->mem.base) {
		fprintf(fd, "(");
		locprint(fd, l->mem.base, 'r');
		if (l->mem.idx) {
			fprintf(fd, ",");
			locprint(fd, l->mem.idx, 'r');
		}
		if (l->mem.scale > 1)
			fprintf(fd, ",%d", l->mem.scale);
		if (l->mem.base)
			fprintf(fd, ")");
	} else if (l->type != Locmeml) {
		die("Only locmeml can have unspecified base reg");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, (%rsi)
jne 0x52b3
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x52c4
leaq 0x26586(%rip), %rsi     # 0x2b82d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x52c4
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x52c4
movq %rbx, %rsi
callq 0x4190
cmpq $0x0, 0x28(%r14)
je 0x5339
pushq $0x28
popq %rdi
movq %rbx, %rsi
callq 0x41f0
movq 0x28(%r14), %rsi
pushq $0x72
popq %rdx
movq %rbx, %rdi
callq 0x5355
cmpq $0x0, 0x30(%r14)
je 0x5306
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x41f0
movq 0x30(%r14), %rsi
pushq $0x72
popq %rdx
movq %rbx, %rdi
callq 0x5355
movl 0x20(%r14), %edx
cmpl $0x2, %edx
jl 0x5320
leaq 0x262aa(%rip), %rsi     # 0x2b5c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x28(%r14)
je 0x533f
pushq $0x29
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41f0
cmpl $0x4, (%r14)
jne 0x5347
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x26276(%rip), %rdi     # 0x2b5c4
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gengas.c
// Function: genstrings
void
genstrings(FILE *fd, Htab *strtab)
{
	void **k;
	Str *s;
	size_t i, nk;

	k = htkeys(strtab, &nk);
	for (i = 0; i < nk; i++) {
		s = k[i];
		fprintf(fd, "%s:\n", (char*)htget(strtab, k[i]));
		writebytes(fd, s->buf, s->len);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2a529
movq %rax, %r15
leaq 0x265d1(%rip), %r12     # 0x2bd5b
xorl %ebp, %ebp
cmpq (%rsp), %rbp
jae 0x57c6
movq (%r15,%rbp,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2a3e8
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
movq (%r13), %rdx
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x57d5
incq %rbp
jmp 0x578c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gengas.c
// Function: writebytes
static void
writebytes(FILE *fd, char *p, size_t sz)
{
	size_t i;

	for (i = 0; i < sz; i++) {
		if (i % 60 == 0)
			fprintf(fd, "\t.ascii \"");
		if (p[i] == '"' || p[i] == '\\')
			fprintf(fd, "\\");
		if (isprint(p[i]))
			fprintf(fd, "%c", p[i]);
		else
			fprintf(fd, "\\%03o", (uint8_t)p[i] & 0xff);
		/* line wrapping for readability */
		if (i % 60 == 59 || i == sz - 1)
			fprintf(fd, "\"\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x1(%rdx), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r13, %rax
xorl %edx, %edx
pushq $0x3c
popq %rcx
divq %rcx
cmpq %r13, %rbx
je 0x58ae
imulq $0x3c, %rax, %rbp
cmpq %r13, %rbp
jne 0x5826
leaq 0x26524(%rip), %rdi     # 0x2bd3c
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x4330
movzbl (%r14,%r13), %r12d
cmpl $0x5c, %r12d
je 0x5837
cmpl $0x22, %r12d
jne 0x5846
pushq $0x5c
popq %rdi
movq %r15, %rsi
callq 0x41f0
movb (%r14,%r13), %r12b
callq 0x4390
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x5870
movzbl %r12b, %edx
movq %r15, %rdi
leaq 0x264df(%rip), %rsi     # 0x2bd46
xorl %eax, %eax
callq 0x4240
jmp 0x587c
movsbl %r12b, %edi
movq %r15, %rsi
callq 0x41f0
addq $0x3b, %rbp
cmpq %r13, %rbp
setne %al
cmpq %r13, (%rsp)
setne %cl
testb %al, %cl
jne 0x58a6
leaq 0x26d64(%rip), %rdi     # 0x2c5fc
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x4330
incq %r13
jmp 0x57f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gengas.c
// Function: genblob
void
genblob(FILE *fd, Node *blob, Htab *globls, Htab *strtab)
{
	char *lbl;
	Blob *b;

	/* lits and such also get wrapped in decls */
	assert(blob->type == Ndecl);

	lbl = htget(globls, blob);
	if (blob->decl.vis != Visintern)
		fprintf(fd, ".globl %s\n", lbl);
	if (asmsyntax == Gnugaself)
		fprintf(fd, ".section .data.%s,\"aw\",@progbits\n", lbl);
	if (blob->decl.init) {
		fprintf(fd, ".align %zd\n", tyalign(decltype(blob)));
		fprintf(fd, "%s:\n", lbl);

		b = litblob(globls, strtab, blob->decl.init);
		writeblob(fd, b);
		blobfree(b);
	} else {
		fprintf(fd, ".comm %s,%zd\n", lbl, size(blob));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xb, 0x8(%rsi)
jne 0x59ba
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2a3e8
movq %rax, %r13
cmpb $0x0, 0x70(%r12)
je 0x5903
leaq 0x25d9c(%rip), %rsi     # 0x2b692
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x588be(%rip), %rax     # 0x5e1c8
cmpl $0x0, (%rax)
jne 0x5923
leaq 0x25d87(%rip), %rsi     # 0x2b69d
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x30(%r12)
je 0x5992
movq %r12, %rdi
callq 0x1bf2d
movq %rax, %rdi
callq 0x10f67
leaq 0x25d7d(%rip), %rsi     # 0x2b6bf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x26405(%rip), %rsi     # 0x2bd5b
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
movq 0x30(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x45c4
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x59d9
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4568
movq %r12, %rdi
callq 0x10f54
leaq 0x25d2a(%rip), %rsi     # 0x2b6cb
movq %rbx, %rdi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4240
leaq 0x25c90(%rip), %rdi     # 0x2b651
leaq 0x25c49(%rip), %rsi     # 0x2b611
leaq 0x25c96(%rip), %rcx     # 0x2b665
movl $0x194, %edx            # imm = 0x194
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/gengas.c
// Function: writeasm
static void
writeasm(FILE *fd, Isel *s, Func *fn)
{
	size_t i, j;

	switch (asmsyntax) {
	case Gnugaself:
		//fprintf(fd, ".section .text.%s,\"ax\",@progbits\n", fn->name);
		fprintf(fd, ".type %s, @function\n", fn->name);
		break;
	case Gnugasmacho:
		fprintf(fd, ".section __TEXT,__text,regular\n");
		break;
	default:
		die("unknown target");  break;
	}
	if (fn->isexport)
		fprintf(fd, ".globl %s\n", fn->name);
	fprintf(fd, "%s:\n", fn->name);
	for (j = 0; j < s->cfg->nbb; j++) {
		if (!s->bb[j])
			continue;
		for (i = 0; i < s->bb[j]->nlbls; i++)
			fprintf(fd, "%s:\n", s->bb[j]->lbls[i]);
		for (i = 0; i < s->bb[j]->ni; i++)
			iprintf(fd, s->bb[j]->il[i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58171(%rip), %rax     # 0x5e1c8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x607c
testl %eax, %eax
jne 0x613d
movq (%r15), %rdx
leaq 0x25dbc(%rip), %rsi     # 0x2be2c
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x6091
leaq 0x25dbe(%rip), %rdi     # 0x2be41
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x4330
cmpb $0x0, 0x58(%r15)
je 0x60ac
movq (%r15), %rdx
leaq 0x255f0(%rip), %rsi     # 0x2b692
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
movq (%r15), %rdx
leaq 0x25ca5(%rip), %r15     # 0x2bd5b
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
jae 0x6133
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x612e
xorl %r13d, %r13d
cmpq 0x10(%rax), %r13
jae 0x6108
movq 0x8(%rax), %rax
movq (%rax,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
jmp 0x60e0
xorl %r13d, %r13d
cmpq 0x20(%rax), %r13
jae 0x612e
movq 0x18(%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x5585
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
jmp 0x610b
incq %r12
jmp 0x60c6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x25182(%rip), %rdi     # 0x2b2c6
xorl %eax, %eax
callq 0x1205c
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/genp9.c
// Function: writebytes
static size_t
writebytes(FILE *fd, char *name, size_t off, char *p, size_t sz)
{
	size_t i, len;

	assert(sz != 0);
	for (i = 0; i < sz; i++) {
		len = min(sz - i, 8);
		if (i % 8 == 0)
			fprintf(fd, "\tDATA %s+%llu(SB)/%llu,$\"", name, (uvlong)off + i, (uvlong)len);
		if (p[i] == '"' || p[i] == '\\')
			fprintf(fd, "\\");
		if (isprint(p[i]))
			fprintf(fd, "%c", p[i]);
		else
			fprintf(fd, "\\%03o", (uint8_t)p[i] & 0xff);
		/* line wrapping for readability */
		if (i % 8 == 7 || i == sz - 1)
			fprintf(fd, "\"\n");
	}

	return sz;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
testq %r8, %r8
je 0x68e8
movq %rdi, %r13
movq %r8, 0x10(%rsp)
movq %r8, %r12
xorl %ebp, %ebp
movq %r8, %rbx
subq $0x1, %rbx
jb 0x68d4
movq %r12, %rdi
pushq $0x8
popq %rsi
callq 0x2ac08
movq %rbp, %r15
andq $0x7, %r15
jne 0x6842
movq 0x20(%rsp), %rcx
addq %rbp, %rcx
movq %r13, %rdi
leaq 0x25a92(%rip), %rsi     # 0x2c2c5
movq 0x18(%rsp), %rdx
movq %rax, %r8
xorl %eax, %eax
callq 0x4240
movq 0x8(%rsp), %rax
movzbl (%rax,%rbp), %r14d
cmpl $0x5c, %r14d
je 0x6858
cmpl $0x22, %r14d
jne 0x686c
pushq $0x5c
popq %rdi
movq %r13, %rsi
callq 0x41f0
movq 0x8(%rsp), %rax
movb (%rax,%rbp), %r14b
callq 0x4390
movq (%rax), %rax
movsbq %r14b, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x6896
movzbl %r14b, %edx
movq %r13, %rdi
leaq 0x254b9(%rip), %rsi     # 0x2bd46
xorl %eax, %eax
callq 0x4240
jmp 0x68a2
movsbl %r14b, %edi
movq %r13, %rsi
callq 0x41f0
cmpl $0x7, %r15d
setne %al
cmpq $0x1, %r12
setne %cl
testb %al, %cl
jne 0x68c9
leaq 0x25d41(%rip), %rdi     # 0x2c5fc
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rcx
callq 0x4330
incq %rbp
movq %rbx, %r12
jmp 0x6803
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25994(%rip), %rdi     # 0x2c283
leaq 0x25856(%rip), %rsi     # 0x2c14c
leaq 0x2598e(%rip), %rcx     # 0x2c28b
movl $0xc5, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: mkinsnv
static Insn *
mkinsnv(AsmOp op, va_list ap)
{
	Loc *l;
	Insn *i;
	int n;
	static size_t insnid;

	n = 0;
	i = malloc(sizeof(Insn));
	i->op = op;
	i->uid = insnid++;
	while ((l = va_arg(ap, Loc*)) != NULL)
		i->args[n++] = l;
	i->nargs = n;
	return i;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x38
popq %rdi
callq 0x4280
movl %ebp, 0x8(%rax)
movq 0x56f6a(%rip), %rcx     # 0x5de78
leaq 0x1(%rcx), %rdx
movq %rdx, 0x56f5f(%rip)     # 0x5de78
movq %rcx, (%rax)
movl (%rbx), %edx
xorl %ecx, %ecx
cmpl $0x28, %edx
ja 0x6f32
movl %edx, %esi
addq 0x10(%rbx), %rsi
addl $0x8, %edx
movl %edx, (%rbx)
jmp 0x6f3e
movq 0x8(%rbx), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rbx)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x6f50
movq %rsi, 0x10(%rax,%rcx,8)
incq %rcx
jmp 0x6f20
movl %ecx, %ecx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: binop
static Loc *
binop(Isel *s, AsmOp op, Node *x, Node *y)
{
	Loc *a, *b;

	a = selexpr(s, x);
	b = selexpr(s, y);
	a = newr(s, a);
	g(s, op, b, a, NULL);
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x6f5d
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6f5d
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x870d
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: g
static void
g(Isel *s, int op, ...)
{
	va_list ap;
	Insn *i;

	va_start(ap, op);
	i = mkinsnv(op, ap);
	va_end(ap);
	if (debugopt['i']) {
		printf("GEN[uid=%zd] ", i->uid);
		dbgiprintf(stdout, i);
	}
	lappend(&s->curbb->il, &s->curbb->ni, i);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %esi, %r10d
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x8693
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
movl %r10d, %edi
callq 0x6ef4
movq %rax, %r14
leaq 0x55b1b(%rip), %rax     # 0x5e1e0
cmpb $0x0, 0x69(%rax)
je 0x86ee
movq (%r14), %rsi
leaq 0x2441f(%rip), %rdi     # 0x2caf4
xorl %eax, %eax
callq 0x4140
movq 0x388ed(%rip), %rax     # 0x40fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x6039
movq 0x28(%rbx), %rsi
leaq 0x18(%rsi), %rdi
addq $0x20, %rsi
movq %r14, %rdx
callq 0x29b2d
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: newr
static Loc *
newr(Isel *s, Loc *a)
{
	Loc *r;

	r = locreg(a->mode);
	if (a->type == Locreg) {
		if (isfloatmode(a->mode))
			g(s, Imovs, a, r, NULL);
		else
			g(s, Imov, a, r, NULL);
	} else {
		load(s, a, r);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %edi
callq 0x9da2
movq %rax, %rbx
cmpl $0x2, (%r14)
jne 0x873a
movl 0x4(%r14), %edi
callq 0x9cab
testl %eax, %eax
je 0x874a
pushq $0x27
jmp 0x874c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9759
jmp 0x8760
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: mode
static Mode
mode(Node *n)
{
	if (n->type == Nexpr)
		return tymode(exprtype(n));
	else if (n->type == Ndecl)
		return tymode(n->decl.type);
	else
		die("invalid node type");
	return ModeNone;
}

// Assembly:
pushq %rax
movl 0x8(%rdi), %eax
cmpl $0xb, %eax
je 0x8781
cmpl $0x8, %eax
jne 0x878b
callq 0x1bf90
movq %rax, %rdi
jmp 0x8785
movq 0x28(%rdi), %rdi
popq %rax
jmp 0x97ce
leaq 0x243a2(%rip), %rdi     # 0x2cb34
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: memloc
static Loc *
memloc(Isel *s, Node *e, Mode m)
{
	Node **args;
	Loc *l, *b, *o; /* location, base, offset */
	int scale;

	scale = 1;
	l = NULL;
	args = e->expr.args;
	if (exprop(e) == Oadd) {
		b = selexpr(s, args[0]);
		if (ismergablemul(args[1], &scale))
			o = selexpr(s, args[1]->expr.args[0]);
		else
			o = selexpr(s, args[1]);

		if (b->type != Locreg)
			b = inr(s, b);
		if (o->type == Loclit) {
			l = locmem(scale*o->lit, b, NULL, m);
		} else {
			b = inr(s, b);
			o = inr(s, o);
			l = locmems(0, b, o, scale, m);
		}
	} else {
		l = selexpr(s, e);
		l = inr(s, l);
		l = locmem(0, l, NULL, m);
	}
	assert(l != NULL);
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rsi), %r13
movq %rsi, %rdi
callq 0x1b5e6
cmpl $0x2, %eax
jne 0x8831
movq (%r13), %rsi
movq %r14, %rdi
callq 0x6f5d
movq %rax, %r15
movq 0x8(%r13), %r12
addq $0x8, %r13
movq %r12, %rdi
callq 0x1b5e6
pushq $0x1
popq %rbp
cmpl $0x4, %eax
jne 0x8850
movq 0x50(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x1b5e6
cmpl $0x35, %eax
jne 0x8850
movq 0x50(%r12), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8850
cmpl $0x2, 0x18(%rax)
jne 0x8850
movl %ebp, %ecx
movl 0x30(%rax), %ebp
cmpl $0x8, %ebp
ja 0x884e
movl $0x114, %eax            # imm = 0x114
btl %ebp, %eax
jae 0x884e
movq (%r13), %rax
movq 0x50(%rax), %r13
jmp 0x8850
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f5d
movq %r14, %rdi
movq %rax, %rsi
callq 0x8626
xorl %edi, %edi
movq %rax, %rsi
jmp 0x8885
movl %ecx, %ebp
movq (%r13), %rsi
movq %r14, %rdi
callq 0x6f5d
movq %rax, %r12
cmpl $0x2, (%r15)
je 0x8873
movq %r14, %rdi
movq %r15, %rsi
callq 0x8626
movq %rax, %r15
cmpl $0x5, (%r12)
jne 0x8890
movl %ebp, %edi
imulq 0x10(%r12), %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x9e39
jmp 0x88bb
movq %r14, %rdi
movq %r15, %rsi
callq 0x8626
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x8626
xorl %edi, %edi
movq %r15, %rsi
movq %rax, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x9e7c
testq %rax, %rax
je 0x88cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a5fc(%rip), %rdi     # 0x32ed2
leaq 0x24199(%rip), %rsi     # 0x2ca76
leaq 0x24262(%rip), %rcx     # 0x2cb46
movl $0x1d3, %edx            # imm = 0x1D3
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: loc
static Loc *
loc(Isel *s, Node *n)
{
	Node *v;
	Ucon *uc;
	Loc *l;

	if (n->type == Ndecl) {
		l = varloc(s, n);
	} else {
		switch (exprop(n)) {
		case Ovar:
			l = varloc(s, n);
			break;
		case Oucon:
			uc = finducon(exprtype(n), n->expr.args[0]);
			l = loclit(uc->id, mode(n));
			break;
		case Olit:
			v = n->expr.args[0];
			switch (v->lit.littype) {
			case Lvoid:	l = NULL;	break;
			case Lchr:	l = loclit(v->lit.chrval, mode(n));	break;
			case Lbool:	l = loclit(v->lit.boolval, mode(n));	break;
			case Lint:	l = loclit(v->lit.intval, mode(n));	break;
			default:
					die("Literal type %s should be blob", litstr[v->lit.littype]);
			}
			break;
		default:
			die("Node %s not leaf in loc()", opstr[exprop(n)]);
			break;
		}
	}
	return l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xb, 0x8(%rsi)
je 0x8950
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x36, %eax
je 0x898c
cmpl $0x35, %eax
je 0x8962
cmpl $0x33, %eax
jne 0x89d6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b04
movq 0x50(%rbx), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
cmpq $0x7, %rcx
ja 0x89f9
leaq 0x23f8f(%rip), %rdx     # 0x2c90c
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl 0x30(%rax), %r14d
jmp 0x89a7
movq %rbx, %rdi
callq 0x1bf90
movq 0x50(%rbx), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x203ff
movq 0x8(%rax), %r14
movq %rbx, %rdi
callq 0x8769
movq %r14, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9eed
movq 0x30(%rax), %r14
jmp 0x89a7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq 0x30(%rax), %r14
jmp 0x89a7
movq %rbx, %rdi
callq 0x1b5e6
movl %eax, %eax
leaq 0x549b9(%rip), %rcx     # 0x5d3a0
movq (%rcx,%rax,8), %rsi
leaq 0x242a9(%rip), %rdi     # 0x2cc9b
xorl %eax, %eax
callq 0x1205c
leaq 0x55310(%rip), %rax     # 0x5dd10
movq (%rax,%rcx,8), %rsi
leaq 0x24271(%rip), %rdi     # 0x2cc7c
jmp 0x89f2
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: blit
static void
blit(Isel *s, Loc *to, Loc *from, size_t dstoff, size_t srcoff, size_t sz, size_t align)
{
	size_t i, modesz;
	Loc *sp, *dp; /* pointers to src, dst */
	Loc *tmp, *src, *dst; /* source memory, dst memory */

	assert(szmodes[align] != ModeNone);   /* make sure we have a valid alignment */
	if (!sz)
		return;
	sp = inr(s, from);
	dp = inr(s, to);

	i = 0;
	if (align == 0)
		align = 8;
	for (modesz = align; szmodes[modesz] != ModeNone; modesz /= 2) {
		tmp = locreg(szmodes[modesz]);
		while (i + modesz <= sz) {
			src = locmem(i + srcoff, sp, NULL, szmodes[modesz]);
			dst = locmem(i + dstoff, dp, NULL, szmodes[modesz]);
			g(s, Imov, src, tmp, NULL);
			g(s, Imov, tmp, dst, NULL);
			i += modesz;
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movl $0xe9, %eax
btq %r9, %rax
jb 0x8b3c
movq %r8, %r13
testq %r8, %r8
je 0x8b2d
movq %r9, %rbx
movq %rsi, %r14
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x8626
movq %rax, 0x20(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x8626
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
pushq $0x8
popq %r14
cmovneq %rbx, %r14
xorl %r12d, %r12d
movl $0xe9, %eax
btq %r14, %rax
jb 0x8b2d
leaq 0x23ef1(%rip), %rax     # 0x2c980
movl (%rax,%r14,4), %edi
movl %edi, 0xc(%rsp)
callq 0x9da2
movq %rax, 0x30(%rsp)
leaq (%r12,%r14), %rbp
cmpq %r13, %rbp
ja 0x8b25
movq %r12, %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
movl 0xc(%rsp), %ebx
movl %ebx, %ecx
callq 0x9e39
movq %r13, %r15
movq %rax, %r13
addq 0x28(%rsp), %r12
movq %r12, %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0x9e39
movq %rax, %r12
movq %r14, %rbx
movq 0x10(%rsp), %r14
movq %r14, %rdi
pushq $0x1
popq %rsi
movq %r13, %rdx
movq %r15, %r13
movq 0x30(%rsp), %r15
movq %r15, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
movq %r14, %rdi
movq %rbx, %r14
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
movq %rbp, %r12
jmp 0x8aa1
shrq %r14
jmp 0x8a79
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24172(%rip), %rdi     # 0x2ccb5
leaq 0x23f2c(%rip), %rsi     # 0x2ca76
leaq 0x2417f(%rip), %rcx     # 0x2ccd0
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: movearg
static void
movearg(Isel *s, Loc *dst, PassIn p, Mode m, size_t *nfloats, size_t *nints, size_t *argoff)
{
	Loc *a;
	assert(m != ModeNone);

	switch(p) {
	case PassInInt:
		a = coreg(intargregs[*nints], forceintmode(m));
		g(s, Imov, a, dst, NULL);
		(*nints)++;
		break;
	case PassInSSE:
		a = coreg(floatargregs[*nfloats], forcefltmode(m));
		g(s, Imovs, a, dst, NULL);
		(*nfloats)++;
		break;
	default: /* no need to move if on stack */
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %edx
jne 0x8f0c
movq %r9, %r15
movq (%r9), %rax
leaq 0x3833f(%rip), %rdx     # 0x41220
movl (%rdx,%rax,8), %ebp
movl %ecx, %edi
callq 0x9c6a
movl %ebp, %edi
movl %eax, %esi
callq 0x9f13
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
jmp 0x8f45
movq %r8, %r12
movq (%r8), %rax
leaq 0x382c7(%rip), %rdx     # 0x411e0
movl (%rdx,%rax,8), %ebp
movl %ecx, %edi
callq 0x9c37
movl %ebp, %edi
movl %eax, %esi
callq 0x9f13
pushq $0x27
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
movq %r12, %r15
incq (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: plus8
static Loc *
plus8(Isel *s, Loc *base)
{
	Loc *forcedreg = locreg(ModeQ);
	if (base->type == Loclbl || (base->type == Locmeml && !base->mem.base)) {
		forcedreg = loclitl(base->lbl);
	} else {
		g(s, Ilea, base, forcedreg, NULL);
	}
	return locmem(8, forcedreg, NULL, ModeQ);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x4
popq %rdi
callq 0x9da2
movq %rax, %rbx
movl (%r14), %eax
cmpl $0x1, %eax
je 0x8f93
cmpl $0x4, %eax
jne 0x8f7b
cmpq $0x0, 0x28(%r14)
je 0x8f93
pushq $0x5
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8633
jmp 0x8f9f
movq 0x10(%r14), %rdi
callq 0x9ced
movq %rax, %rbx
pushq $0x8
popq %rdi
pushq $0x4
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x9e39
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: load
static void
load(Isel *s, Loc *a, Loc *b)
{
	Loc *l;

	assert(b->type == Locreg);
	if (a->type == Locreg)
		l = locmem(0, b, NULL, a->mode);
	else
		l = a;
	if (isfloatmode(b->mode))
		g(s, Imovs, l, b, NULL);
	else
		g(s, Imov, l, b, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, (%rdx)
jne 0x97af
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x2, (%rsi)
jne 0x9784
movl 0x4(%r15), %ecx
xorl %edi, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x9e39
movq %rax, %r15
movl 0x4(%rbx), %edi
callq 0x9cab
testl %eax, %eax
pushq $0x1
popq %rax
pushq $0x27
popq %rsi
cmovel %eax, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8633
leaq 0x2334c(%rip), %rdi     # 0x2cb02
leaq 0x232b9(%rip), %rsi     # 0x2ca76
leaq 0x23350(%rip), %rcx     # 0x2cb14
movl $0x10e, %edx            # imm = 0x10E
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: tymode
static Mode
tymode(Type *t)
{
	/* FIXME: What should the mode for, say, structs be when we have no
	 * intention of loading /through/ the pointer? For now, we'll just say it's
	 * the pointer mode, since we expect to address through the pointer */
	t = tybase(t);
	switch (t->type) {
	case Tyflt32:	return ModeF;	break;
	case Tyflt64:	return ModeD;	break;
	default:
		if (isstacktype(t))
			return ModeQ;
		switch (tysize(t)) {
		case 1:	return ModeB;	break;
		case 2:	return ModeW;	break;
		case 4:	return ModeL;	break;
		case 8:	return ModeQ;	break;
		}
		break;
	}
	return ModeNone;
}

// Assembly:
pushq %rbx
callq 0x1fcd8
movq %rax, %rbx
movl (%rax), %eax
cmpl $0xf, %eax
je 0x97e7
cmpl $0x10, %eax
jne 0x97eb
pushq $0x6
jmp 0x97f9
pushq $0x5
jmp 0x97f9
movq %rbx, %rdi
callq 0x1fcb0
testl %eax, %eax
je 0x97fc
pushq $0x4
popq %rax
popq %rbx
retq
movq %rbx, %rdi
callq 0x10d64
movq %rax, %rcx
leaq -0x1(%rax), %rdx
xorl %eax, %eax
cmpq $0x7, %rdx
ja 0x97fa
leaq 0x2350e(%rip), %rax     # 0x2cd28
movl -0x4(%rax,%rcx,4), %eax
jmp 0x97fa
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: tymodepart
static Mode tymodepart(Type *t, int is_float, size_t displacement)
{
	assert(isstacktype(t));
	size_t sz = tysize(t);

	if (is_float) {
		switch(sz - displacement) {
		case 4: return ModeF; break;
		default: return ModeD; break;
		}
	} else {
		switch(sz - displacement) {
		case 1: return ModeB; break;
		case 2: return ModeW; break;
		case 4: return ModeL; break;
		default: return ModeQ; break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x1fcb0
testl %eax, %eax
je 0x9876
movq %r15, %rdi
callq 0x10d64
movq %rax, %rcx
subq %r14, %rcx
testl %ebx, %ebx
je 0x9856
xorl %eax, %eax
cmpq $0x4, %rcx
setne %al
addl $0x5, %eax
jmp 0x9870
leaq -0x1(%rcx), %rax
cmpq $0x3, %rax
ja 0x986d
leaq 0x234e1(%rip), %rax     # 0x2cd48
movl -0x4(%rax,%rcx,4), %eax
jmp 0x9870
pushq $0x4
popq %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x232eb(%rip), %rdi     # 0x2cb68
leaq 0x231f2(%rip), %rsi     # 0x2ca76
leaq 0x232ec(%rip), %rcx     # 0x2cb77
pushq $0x5c
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/isel.c
// Function: varloc
static Loc *
varloc(Isel *s, Node *n)
{
	ssize_t off;
	Loc *l, *rip;

	/* we need to try getting it from the stack first, in case we
	 * forced it to stack for addressing */
	if (hthas(s->globls, n)) {
		rip = locphysreg(Rrip);
		l = locmeml(htget(s->globls, n), rip, NULL, mode(n));
	} else if (hthas(s->envoff, n)) {
		off = ptoi(htget(s->envoff, n));
		l = locmem(off, s->envp, NULL, mode(n));
	} else if (hthas(s->stkoff, n)) {
		off = ptoi(htget(s->stkoff, n));
		l = locmem(-off, locphysreg(Rrbp), NULL, mode(n));
	} else if (stacknode(n)) {
		assert(0);
	} else {
		l = htget(s->reglocs, n);
		if (!l) {
			l = locreg(mode(n));
			htput(s->reglocs, n, l);
		}
	}
	return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rdi
callq 0x2a517
testl %eax, %eax
je 0x9b52
pushq $0x65
popq %rdi
callq 0x9e02
movq %rax, %r15
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x8769
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x9e8c
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2a517
testl %eax, %eax
je 0x9b85
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
movq %rax, %r15
movq 0x68(%r14), %r14
movq %rbx, %rdi
callq 0x8769
movq %r15, %rdi
movq %r14, %rsi
jmp 0x9bc0
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2a517
testl %eax, %eax
je 0x9bce
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
movq %rax, %r14
negq %r14
pushq $0x3c
popq %rdi
callq 0x9e02
movq %rax, %r15
movq %rbx, %rdi
callq 0x8769
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x9e39
movq %rbx, %rdi
callq 0xd8a8
testl %eax, %eax
jne 0x9c18
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
movq %rax, %r15
testq %rax, %rax
jne 0x9c0f
movq %rbx, %rdi
callq 0x8769
movl %eax, %edi
callq 0x9da2
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a22a
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x24392(%rip), %rdi     # 0x2dfb1
leaq 0x22e50(%rip), %rsi     # 0x2ca76
leaq 0x23033(%rip), %rcx     # 0x2cc60
movl $0xa2, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: locstrlbl
Loc *
locstrlbl(char *lbl)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Loclbl;
	l->mode = ModeQ;
	l->lbl = strdup(lbl);
	return l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x29a78
movq %rax, %r14
movabsq $0x400000001, %rax      # imm = 0x400000001
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: loclitl
Loc *
loclitl(char *lbl)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Loclitl;
	l->mode = ModeQ;
	l->lbl = strdup(lbl);
	return l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x29a78
movq %rax, %r14
movabsq $0x400000006, %rax      # imm = 0x400000006
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: loclbl
Loc *
loclbl(Node *e)
{
	Node *lbl;
	assert(e->type == Nexpr);
	lbl = e->expr.args[0];
	assert(lbl->type == Nlit);
	assert(lbl->lit.littype == Llbl);
	return locstrlbl(lbl->lit.lblval);
}

// Assembly:
pushq %rax
cmpl $0x8, 0x8(%rdi)
jne 0x9d47
movq 0x50(%rdi), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x9d60
cmpl $0x6, 0x18(%rax)
jne 0x9d79
movq 0x30(%rax), %rdi
popq %rax
jmp 0x9cb7
leaq 0x2300a(%rip), %rdi     # 0x2cd58
leaq 0x23014(%rip), %rsi     # 0x2cd69
leaq 0x23014(%rip), %rcx     # 0x2cd70
pushq $0x44
jmp 0x9d90
leaq 0x2301d(%rip), %rdi     # 0x2cd84
leaq 0x22ffb(%rip), %rsi     # 0x2cd69
leaq 0x22ffb(%rip), %rcx     # 0x2cd70
pushq $0x46
jmp 0x9d90
leaq 0x23016(%rip), %rdi     # 0x2cd96
leaq 0x22fe2(%rip), %rsi     # 0x2cd69
leaq 0x22fe2(%rip), %rcx     # 0x2cd70
pushq $0x47
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: locmem
Loc *
locmem(long disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Locmem;
	l->mode = mode;
	l->mem.constdisp = disp;
	l->mem.base = base;
	l->mem.idx = idx;
	l->mem.scale = 1;
	return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x38
popq %rdi
callq 0x29a78
movl $0x3, (%rax)
movl %ebx, 0x4(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movl $0x1, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: locmeml
Loc *
locmeml(char *disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Locmeml;
	l->mode = mode;
	l->mem.lbldisp = strdup(disp);
	l->mem.base = base;
	l->mem.idx = idx;
	l->mem.scale = 1;
	return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x38
popq %rdi
callq 0x29a78
movq %rax, %r13
movl $0x4, (%rax)
movl %ebx, 0x4(%rax)
movq %r12, %rdi
callq 0x4340
movq %rax, 0x10(%r13)
movq %r15, 0x28(%r13)
movq %r14, 0x30(%r13)
movl $0x1, 0x20(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/locs.c
// Function: loclit
Loc *
loclit(long val, Mode m)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Loclit;
	l->mode = m;
	l->lit = val;
	return l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x29a78
movl $0x5, (%rax)
movl %ebx, 0x4(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/main.c
// Function: usage
static void
usage(char *prog)
{
	printf("%s [-?|-h] [-o outfile] [-O dir] [-d[dbgopts]] inputs\n", prog);
	printf("\t-?|-h\tPrint this help\n");
	printf("\t-o\tOutput to outfile\n");
	printf("\t-O dir\tOutput to dir\n");
	printf("\t-S\tGenerate assembly source alongside object code\n");
	printf("\t-T\tCompile in test mode\n");
	printf("\t-c\tEnable additional (possibly flaky) checking\n");
	printf("\t-I path\tAdd 'path' to use search path\n");
	printf("\t-d\tPrint debug dumps. Recognized options: f r p i\n");
	printf("\t-G\tGenerate asm in gas syntax\n");
	printf("\t-9\tGenerate asm in plan 9 syntax\n");
	printf("\t-d opts: additional debug logging. Options are listed below:\n");
	printf("\t\tf: log folded trees\n");
	printf("\t\tl: log lowered pre-cfg trees\n");
	printf("\t\tT: log tree immediately\n");
	printf("\t\tr: log register allocation activity\n");
	printf("\t\ti: log instruction selection activity\n");
	printf("\t\tu: log type unifications\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x234ab(%rip), %rdi     # 0x2daee
xorl %eax, %eax
callq 0x4140
leaq 0x2358e(%rip), %rdi     # 0x2dbdf
callq 0x40b0
leaq 0x23599(%rip), %rdi     # 0x2dbf6
callq 0x40b0
leaq 0x235a3(%rip), %rdi     # 0x2dc0c
callq 0x40b0
leaq 0x235ad(%rip), %rdi     # 0x2dc22
callq 0x40b0
leaq 0x235d4(%rip), %rdi     # 0x2dc55
callq 0x40b0
leaq 0x235e1(%rip), %rdi     # 0x2dc6e
callq 0x40b0
leaq 0x23605(%rip), %rdi     # 0x2dc9e
callq 0x40b0
leaq 0x23620(%rip), %rdi     # 0x2dcc5
callq 0x40b0
leaq 0x23647(%rip), %rdi     # 0x2dcf8
callq 0x40b0
leaq 0x2365a(%rip), %rdi     # 0x2dd17
callq 0x40b0
leaq 0x23670(%rip), %rdi     # 0x2dd39
callq 0x40b0
leaq 0x236a2(%rip), %rdi     # 0x2dd77
callq 0x40b0
leaq 0x236ac(%rip), %rdi     # 0x2dd8d
callq 0x40b0
leaq 0x236bf(%rip), %rdi     # 0x2ddac
callq 0x40b0
leaq 0x236cd(%rip), %rdi     # 0x2ddc6
callq 0x40b0
leaq 0x236e7(%rip), %rdi     # 0x2ddec
callq 0x40b0
leaq 0x23703(%rip), %rdi     # 0x2de14
popq %rax
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/main.c
// Function: dirname
static char *
dirname(char *path)
{
	char *p;

	p = strrchr(path, '/');
	if (p)
		return strdupn(path, p - path);
	else
		return xstrdup(".");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x2f
popq %rsi
callq 0x4160
testq %rax, %rax
je 0xa737
subq %rbx, %rax
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x2aa68
leaq 0x2975d(%rip), %rdi     # 0x33e9b
popq %rbx
jmp 0x2aa9b
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/main.c
// Function: swapout
static void
swapout(char* buf, size_t sz, char* suf) {
	char* psuffix;
	psuffix = strrchr(outfile, '.');
	if (psuffix != NULL)
		swapsuffix(buf, sz, outfile, psuffix, suf);
	else
		bprintf(buf, sz, "%s%s", outfile, suf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x53a6a(%rip), %r14     # 0x5e1c0
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x4160
testq %rax, %rax
je 0xa781
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x2ab21
leaq 0x233bb(%rip), %rdx     # 0x2db43
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2a9bf
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/main.c
// Function: mkpath
static void
mkpath(char *p)
{
	char *e, path[256];

	e = p;
	assert(strlen(p) < sizeof(path));
	while ((e = strstr(e, "/")) != NULL) {
		memcpy(path, p, (e - p));
		path[e - p] = 0;
		mkdir(path, 0755);
		e++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
callq 0x4120
cmpq $0xff, %rax
ja 0xa817
pushq $0x2f
popq %rbp
movq %rsp, %r14
movq %rbx, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x4130
testq %rax, %rax
je 0xa807
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4270
movb $0x0, (%rsp,%r12)
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x40a0
incq %r15
jmp 0xa7ca
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23346(%rip), %rdi     # 0x2db64
leaq 0x23358(%rip), %rsi     # 0x2db7d
leaq 0x23358(%rip), %rcx     # 0x2db84
pushq $0x4b
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: issubreg
int
issubreg(Loc *a, Loc *b)
{
	if(a->type != Locreg || b->type != Locreg)
		return 0;
	if(a->reg.colour == Rnone || b->reg.colour == Rnone)
		return 0;
	return rclass(a) == rclass(b) && a->mode != b->mode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x2, (%rdi)
jne 0xa896
movq %rsi, %r14
cmpl $0x2, (%rsi)
jne 0xa896
movq %rdi, %r15
cmpl $0x0, 0x18(%rdi)
je 0xa896
cmpl $0x0, 0x18(%r14)
je 0xa896
movq %r15, %rdi
callq 0xa834
movl %eax, %ebp
movq %r14, %rdi
callq 0xa834
cmpl %eax, %ebp
jne 0xa896
movl 0x4(%r15), %eax
xorl %ebx, %ebx
cmpl 0x4(%r14), %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq