LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: replacealias
void
replacealias(Isel *s, Loc **map, size_t nreg, Insn *insn)
{
	size_t i;
	Loc *l;

	if (!map)
		return;
	for (i = 0; i < insn->nargs; i++) {
		l = insn->args[i];
		if (l->type == Locreg) {
			insn->args[i] = locmap[getalias(s, l->reg.id)];
		} else if (l->type == Locmem || l->type == Locmeml) {
			if (l->mem.base)
				l->mem.base = locmap[getalias(s, l->mem.base->reg.id)];
			if (l->mem.idx)
				l->mem.idx = locmap[getalias(s, l->mem.idx->reg.id)];
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0xa96b
movq %rcx, %rbx
leaq 0x10(%rcx), %r13
xorl %r12d, %r12d
cmpq 0x30(%rbx), %r12
jae 0xa96b
movq (%r13), %rbp
movl (%rbp), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xa939
movq 0x28(%rbp), %rax
testq %rax, %rax
je 0xa924
leaq 0x53574(%rip), %rcx     # 0x5de80
movq (%rcx), %r15
movq 0x10(%rax), %rsi
movq (%rsp), %rdi
callq 0xa97a
movq (%r15,%rax,8), %rax
movq %rax, 0x28(%rbp)
movq 0x30(%rbp), %rax
testq %rax, %rax
je 0xa95f
movq %rbp, %r15
addq $0x30, %r15
movq %rax, %rbp
jmp 0xa941
movq %r13, %r15
cmpl $0x2, %eax
jne 0xa95f
leaq 0x53538(%rip), %rax     # 0x5de80
movq (%rax), %r14
movq 0x10(%rbp), %rsi
movq (%rsp), %rdi
callq 0xa97a
movq (%r14,%rax,8), %rax
movq %rax, (%r15)
incq %r12
addq $0x8, %r13
jmp 0xa8e7
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/ra.c
// Function: gfree
static void
gfree(Isel *s)
{
	size_t i;

	for (i = 0; i < s->nreg; i++)
		free(s->gadj[i]);
	free(s->gbits);
	free(s->gadj);
	free(s->ngadj);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x3d0(%rbx), %r14
jae 0xc6d0
movq 0x3b8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4040
incq %r14
jmp 0xc6b2
movq 0x3b0(%rbx), %rdi
callq 0x4040
movq 0x3b8(%rbx), %rdi
callq 0x4040
movq 0x3c0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: wlprint
void
wlprint(FILE *fd, char *name, Loc **wl, size_t nwl)
{
	size_t i;
	char *sep;

	sep = "";
	fprintf(fd, "%s = [", name);
	for (i = 0; i < nwl; i++) {
		fprintf(fd, "%s", sep);
		dbglocprint(fd, wl[i], 'x');
		fprintf(fd, "(%zd)", wl[i]->reg.id);
		sep = ",";
	}
	fprintf(fd, "]\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x21716(%rip), %rsi     # 0x2de2f
xorl %eax, %eax
callq 0x4240
leaq 0x21723(%rip), %rdi     # 0x2de4a
leaq 0x21708(%rip), %r12     # 0x2de36
leaq 0x28637(%rip), %r13     # 0x34d6c
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0xc770
movq %rbx, %rsi
callq 0x4190
movq (%r15,%rbp,8), %rsi
movq %rbx, %rdi
pushq $0x78
popq %rdx
callq 0x6034
movq (%r15,%rbp,8), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4240
incq %rbp
movq %r13, %rdi
jmp 0xc737
leaq 0x22436(%rip), %rdi     # 0x2ebad
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4330
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: printedge
static void
printedge(FILE *fd, char *msg, size_t a, size_t b)
{
	fprintf(fd, "\t%s ", msg);
	dbglocprint(fd, locmap[a], 'x');
	fprintf(fd, " -- ");
	dbglocprint(fd, locmap[b], 'x');
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x218d9(%rip), %rsi     # 0x2e0ae
xorl %eax, %eax
callq 0x4240
leaq 0x5169d(%rip), %r12     # 0x5de80
movq (%r12), %rax
movq (%rax,%r15,8), %rsi
pushq $0x78
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x6034
leaq 0x218b4(%rip), %rdi     # 0x2e0b3
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x4330
movq (%r12), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x6034
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: setprint
static void
setprint(FILE *fd, Bitset *s)
{
	char *sep;
	size_t i;

	sep = "";
	for (i = 0; i < bsmax(s); i++) {
		if (bshas(s, i)) {
			fprintf(fd, "%s%zd", sep, i);
			sep = ",";
		}
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x21600(%rip), %r12     # 0x2de4a
leaq 0x21867(%rip), %r15     # 0x2e0b8
leaq 0x28514(%rip), %rbp     # 0x34d6c
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x29ecd
cmpq %rax, %r13
jae 0xc892
movq %r14, %rdi
movq %r13, %rsi
callq 0xcada
testl %eax, %eax
je 0xc88d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4240
movq %rbp, %r12
incq %r13
jmp 0xc85b
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: locsetprint
static void
locsetprint(FILE *fd, Bitset *s)
{
	char *sep;
	size_t i;

	sep = "";
	for (i = 0; i < bsmax(s); i++) {
		if (bshas(s, i)) {
			fprintf(fd, "%s", sep);
			dbglocprint(fd, locmap[i], 'x');
			sep = ",";
		}
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x21587(%rip), %r12     # 0x2de4a
xorl %r15d, %r15d
pushq $0x78
popq %rbp
leaq 0x2849c(%rip), %r13     # 0x34d6c
movq %r14, %rdi
callq 0x29ecd
cmpq %rax, %r15
jae 0xc917
movq %r14, %rdi
movq %r15, %rsi
callq 0xcada
testl %eax, %eax
je 0xc912
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4190
leaq 0x51582(%rip), %rax     # 0x5de80
movq (%rax), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x6034
movq %r13, %r12
incq %r15
jmp 0xc8d0
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: uses
static size_t
uses(Insn *insn, regid *u)
{
	size_t i, j;
	int k;
	Loc *m;

	j = 0;
	/* Add all the registers used and defined. Duplicate
	 * in this list are fine, since they're being added to
	 * a set anyways */
	for (i = 0; i < Maxarg; i++) {
		if (!usetab[insn->op].l[i])
			break;
		k = usetab[insn->op].l[i] - 1;
		/* non-registers are handled later */
		if (insn->args[k]->type == Locreg)
			if (!isfixreg(insn->args[k]))
				u[j++] = insn->args[k]->reg.id;
	}
	/* some insns don't reflect their defs in the args.
	 * These are explictly listed in the insn description */
	for (i = 0; i < Nreg; i++) {
		if (!usetab[insn->op].r[i])
			break;
		/* not a leak; physical registers get memoized */
		u[j++] = locphysreg(usetab[insn->op].r[i])->reg.id;
	}
	/* If the registers are in an address calculation,
	 * they're used no matter what. */
	for (i = 0; i < insn->nargs; i++) {
		m = insn->args[i];
		if (m->type != Locmem && m->type != Locmeml)
			continue;
		if (m->mem.base)
			if (!isfixreg(m->mem.base))
				u[j++] = m->mem.base->reg.id;
		if (m->mem.idx)
			if (!isfixreg(m->mem.base))
				u[j++] = m->mem.idx->reg.id;
	}
	return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x34f68(%rip), %r12     # 0x418b0
xorl %r15d, %r15d
cmpq $0x10, %rax
je 0xc98e
movl 0x8(%r14), %ecx
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rax, %rcx
movslq (%r12,%rcx), %rcx
testq %rcx, %rcx
je 0xc98e
movq 0x8(%r14,%rcx,8), %rcx
cmpl $0x2, (%rcx)
jne 0xc988
movl 0x18(%rcx), %edx
addl $-0x2d, %edx
cmpl $-0x3, %edx
ja 0xc988
movq 0x10(%rcx), %rcx
movq %rcx, (%rbx,%r15,8)
incq %r15
addq $0x4, %rax
jmp 0xc94b
movl $0x19c, %r13d           # imm = 0x19C
cmpq $0x334, %r13            # imm = 0x334
je 0xc9c9
movl 0x8(%r14), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
addq %r13, %rax
movl (%r12,%rax), %edi
testl %edi, %edi
je 0xc9c9
callq 0x9e02
movq 0x10(%rax), %rax
movq %rax, (%rbx,%r15,8)
incq %r15
addq $0x4, %r13
jmp 0xc994
xorl %eax, %eax
cmpq 0x30(%r14), %rax
jae 0xca27
movq 0x10(%r14,%rax,8), %rcx
movl (%rcx), %edx
addl $-0x3, %edx
cmpl $0x1, %edx
ja 0xca22
movq 0x28(%rcx), %rdx
testq %rdx, %rdx
je 0xc9ff
movl 0x18(%rdx), %esi
addl $-0x2d, %esi
cmpl $-0x3, %esi
ja 0xc9ff
movq 0x10(%rdx), %rdx
movq %rdx, (%rbx,%r15,8)
incq %r15
movq 0x30(%rcx), %rdx
testq %rdx, %rdx
je 0xca22
movq 0x28(%rcx), %rcx
movl 0x18(%rcx), %ecx
addl $-0x2d, %ecx
cmpl $-0x3, %ecx
ja 0xca22
movq 0x10(%rdx), %rcx
movq %rcx, (%rbx,%r15,8)
incq %r15
incq %rax
jmp 0xc9cb
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: defs
static size_t
defs(Insn *insn, regid *d)
{
	size_t i, j;
	int k;

	j = 0;
	/* Add all the registers dsed and defined. Duplicate
	 * in this list are fine, since they're being added to
	 * a set anyways */
	for (i = 0; i < Maxarg; i++) {
		if (!deftab[insn->op].l[i])
			break;
		k = deftab[insn->op].l[i] - 1;
		if (insn->args[k]->type == Locreg)
			if (!isfixreg(insn->args[k]))
				d[j++] = insn->args[k]->reg.id;
	}
	/* some insns don't reflect their defs in the args.
	 * These are explictly listed in the insn description */
	for (i = 0; i < Nreg; i++) {
		if (!deftab[insn->op].r[i])
			break;
		/* not a leak; physical registers get memoized */
		d[j++] = locphysreg(deftab[insn->op].r[i])->reg.id;
	}
	return j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x42944(%rip), %r12     # 0x4f390
xorl %r15d, %r15d
cmpq $0x10, %rax
je 0xca92
movl 0x8(%r14), %ecx
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rax, %rcx
movslq (%r12,%rcx), %rcx
testq %rcx, %rcx
je 0xca92
movq 0x8(%r14,%rcx,8), %rcx
cmpl $0x2, (%rcx)
jne 0xca8c
movl 0x18(%rcx), %edx
addl $-0x2d, %edx
cmpl $-0x3, %edx
ja 0xca8c
movq 0x10(%rcx), %rcx
movq %rcx, (%rbx,%r15,8)
incq %r15
addq $0x4, %rax
jmp 0xca4f
movl $0x19c, %r13d           # imm = 0x19C
cmpq $0x334, %r13            # imm = 0x334
je 0xcacd
movl 0x8(%r14), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
addq %r13, %rax
movl (%r12,%rax), %edi
testl %edi, %edi
je 0xcacd
callq 0x9e02
movq 0x10(%rax), %rax
movq %rax, (%rbx,%r15,8)
incq %r15
addq $0x4, %r13
jmp 0xca98
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: addedge
static void
addedge(Isel *s, regid u, regid v)
{
	if (u == v || gbhasedge(s, u, v))
		return;
	if (u == Rrbp || u == Rrsp || u == Rrip)
		return;
	if (v == Rrbp || v == Rrsp || v == Rrip)
		return;
	if (rclass(locmap[u]) != rclass(locmap[v]))
		return;
	if (bshas(s->prepainted, u) && bshas(s->prepainted, v))
		return;

	gbputedge(s, u, v);
	gbputedge(s, v, u);
	if (!bshas(s->prepainted, u)) {
		alputedge(s, u, v);
		s->degree[u] += degreechange(s, v, u);
	}
	if (!bshas(s->prepainted, v)) {
		alputedge(s, v, u);
		s->degree[v] += degreechange(s, u, v);
	}
}

// Assembly:
cmpq %rdx, %rsi
je 0xcb90
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xc793
testl %eax, %eax
jne 0xcb88
leaq -0x3b(%r15), %rcx
movabsq $0x40000000003, %rax    # imm = 0x40000000003
cmpq $0x2a, %rcx
ja 0xcb91
btq %rcx, %rax
jae 0xcb91
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x3b(%rbx), %rcx
cmpq $0x2a, %rcx
ja 0xcba1
btq %rcx, %rax
jb 0xcb88
leaq 0x512d8(%rip), %rax     # 0x5de80
movq (%rax), %r12
movq (%r12,%r15,8), %rdi
callq 0xa834
movl %eax, %ebp
movq (%r12,%rbx,8), %rdi
callq 0xa834
cmpl %eax, %ebp
jne 0xcb88
movq 0x4c0(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xcada
testl %eax, %eax
je 0xcbe8
movq %r12, %rdi
movq %rbx, %rsi
callq 0xcada
testl %eax, %eax
jne 0xcb88
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xcc86
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xcc86
movq 0x4c0(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xcada
testl %eax, %eax
jne 0xcc48
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xcd1a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xcd96
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%r15,4)
movq 0x4c0(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xcada
testl %eax, %eax
jne 0xcb88
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xcd1a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xcd96
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%rbx,4)
jmp 0xcb88
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: gbputedge
static void
gbputedge(Isel *s, size_t u, size_t v)
{
	size_t i, j;

	i = (s->nreg * u) + v;
	j = (s->nreg * v) + u;
	s->gbits[i/Sizetbits] |= 1ULL << (i % Sizetbits);
	s->gbits[j/Sizetbits] |= 1ULL << (j % Sizetbits);
	assert(gbhasedge(s, u, v) && gbhasedge(s, v, u));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3b0(%rdi), %rdx
movq 0x3d0(%rdi), %rax
movq %rax, %rcx
imulq %rsi, %rcx
addq %r14, %rcx
imulq %r14, %rax
addq %rsi, %rax
pushq $0x1
popq %rsi
movq %rsi, %rdi
shlq %cl, %rdi
shrq $0x6, %rcx
orq %rdi, (%rdx,%rcx,8)
movl %eax, %ecx
shlq %cl, %rsi
shrq $0x6, %rax
orq %rsi, (%rdx,%rax,8)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc793
testl %eax, %eax
je 0xccfb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc793
testl %eax, %eax
je 0xccfb
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21207(%rip), %rdi     # 0x2df09
leaq 0x211bb(%rip), %rsi     # 0x2dec4
leaq 0x21222(%rip), %rcx     # 0x2df32
movl $0x16c, %edx            # imm = 0x16C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: alputedge
static void
alputedge(Isel *s, regid u, regid v)
{
	if (s->ngadj[u] == s->gadjsz[u]) {
		s->gadjsz[u] = s->gadjsz[u]*2 + 1;
		s->gadj[u] = xrealloc(s->gadj[u], s->gadjsz[u]*sizeof(regid));
	}
	s->gadj[u][s->ngadj[u]] = v;
	s->ngadj[u]++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3c0(%rdi), %rcx
movq 0x3c8(%rdi), %rdx
movq (%rcx,%rsi,8), %rax
cmpq (%rdx,%rsi,8), %rax
jne 0xcd7d
leaq 0x1(,%rax,2), %rcx
addq %rax, %rax
movq %rcx, (%rdx,%rbx,8)
movq 0x3b8(%r15), %rcx
movq (%rcx,%rbx,8), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x29b04
movq 0x3b8(%r15), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0x3c0(%r15), %rcx
movq (%rcx,%rbx,8), %rax
movq 0x3b8(%r15), %rdx
movq (%rdx,%rbx,8), %rdx
movq %r14, (%rdx,%rax,8)
incq (%rcx,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: degreechange
static int
degreechange(Isel *s, regid u, regid v)
{
	regid phys, virt, r;
	size_t i;

	if (bshas(s->prepainted, u)) {
		phys = u;
		virt = v;
	} else if (bshas(s->prepainted, v)) {
		phys = v;
		virt = u;
	} else {
		return 1;
	}

	for (i = 0; i < Nmode; i++) {
		r = regmap[colourmap[phys]][i];
		if (r != phys && gbhasedge(s, virt, regmap[colourmap[phys]][i])) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x4c0(%rdi), %r13
movq %r13, %rdi
callq 0xcada
pushq $0x1
popq %rbx
testl %eax, %eax
je 0xcdc8
movq %r15, %r13
movq %r12, %r15
jmp 0xcdda
movq %r13, %rdi
movq %r12, %rsi
callq 0xcada
movq %r12, %r13
testl %eax, %eax
je 0xce21
xorl %r12d, %r12d
leaq 0x503dc(%rip), %rbp     # 0x5d1c0
leaq 0x50085(%rip), %rbx     # 0x5ce70
cmpq $0x1c, %r12
je 0xce1a
movslq (%rbp,%r13,4), %rax
imulq $0x1c, %rax, %rax
addq %r12, %rax
movl (%rbx,%rax), %edx
cmpq %rdx, %r13
je 0xce14
movq %r14, %rdi
movq %r15, %rsi
callq 0xc793
testl %eax, %eax
jne 0xce1f
addq $0x4, %r12
jmp 0xcdeb
pushq $0x1
popq %rbx
jmp 0xce21
xorl %ebx, %ebx
movl %ebx, %eax
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/ra.c
// Function: moverelated
static int
moverelated(Isel *s, regid n)
{
	size_t i;

	for (i = 0; i < s->nrmoves[n]; i++) {
		if (bshas(s->mactiveset, s->rmoves[n][i]->uid))
			return 1;
		if (bshas(s->wlmoveset, s->rmoves[n][i]->uid))
			return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x408(%rdi), %rax
movq (%rax,%rsi,8), %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0xcee3
movq 0x400(%r15), %rax
movq 0x440(%r15), %rdi
movq (%rax,%r14,8), %rax
movq (%rax,%rbp,8), %rax
movq (%rax), %r12
movq %r12, %rsi
callq 0xcada
testl %eax, %eax
jne 0xcede
movq 0x458(%r15), %rdi
movq %r12, %rsi
callq 0xcada
incq %rbp
testl %eax, %eax
je 0xce9e
pushq $0x1
popq %rax
movl %eax, %ebx
movl %ebx, %eax
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/ra.c
// Function: enablemove
static void
enablemove(Isel *s, regid n)
{
	size_t i, j;
	Insn **il;
	size_t ni;

	ni = nodemoves(s, n, &il);
	for (i = 0; i < ni; i++) {
		if (!bshas(s->mactiveset, il[i]->uid))
			continue;
		for (j = 0; j < s->nmactive; j++) {
			if (il[i] == s->mactive[j]) {
				ldel(&s->mactive, &s->nmactive, j);
				lappend(&s->wlmove, &s->nwlmove, il[i]);
				bsdel(s->mactiveset, il[i]->uid);
				bsput(s->wlmoveset, il[i]->uid);
			}
		}
	}
	free(il);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdx
callq 0xd21b
movq %rax, 0x8(%rsp)
movq (%r14), %r14
leaq 0x450(%rbx), %r12
leaq 0x448(%rbx), %r13
leaq 0x460(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x468(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
je 0xd1c9
movq 0x440(%rbx), %rdi
movq (%r14,%r15,8), %rax
movq (%rax), %rsi
callq 0xcada
testl %eax, %eax
je 0xd1c1
xorl %ebp, %ebp
cmpq (%r12), %rbp
jae 0xd1c1
movq (%r14,%r15,8), %rax
movq (%r13), %rcx
cmpq (%rcx,%rbp,8), %rax
jne 0xd1bc
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x29bfa
movq (%r14,%r15,8), %rdx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29b2d
movq 0x440(%rbx), %rdi
movq (%r14,%r15,8), %rax
movq (%rax), %rsi
callq 0x29f3e
movq 0x458(%rbx), %rdi
movq (%r14,%r15,8), %rax
movq (%rax), %rsi
callq 0x29ed5
incq %rbp
jmp 0xd161
incq %r15
jmp 0xd13d
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: nodemoves
static size_t
nodemoves(Isel *s, regid n, Insn ***pil)
{
	size_t i, count;
	regid rid;
	Insn **il;

	count = 0;
	il = malloc(s->nrmoves[n] * sizeof(Insn*));
	for (i = 0; i < s->nrmoves[n]; i++) {
		rid = s->rmoves[n][i]->uid;
		if (bshas(s->mactiveset, rid) || bshas(s->wlmoveset, rid))
			il[count++] = s->rmoves[n][i];
	}
	*pil = il;
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %r15
movq 0x408(%rdi), %rax
movq %rsi, 0x10(%rsp)
movq (%rax,%rsi,8), %rbx
leaq (,%rbx,8), %rdi
callq 0x4280
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xd2aa
movq 0x400(%r15), %rax
movq 0x440(%r15), %rdi
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax,%r12,8), %r14
movq (%r14), %rbp
movq %rbp, %rsi
callq 0xcada
testl %eax, %eax
jne 0xd29a
movq 0x458(%r15), %rdi
movq %rbp, %rsi
callq 0xcada
testl %eax, %eax
je 0xd2a5
movq (%rsp), %rax
movq %r14, (%rax,%r13,8)
incq %r13
incq %r12
jmp 0xd258
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %r13, %rax
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/ra.c
// Function: wladd
static void
wladd(Isel *s, regid u)
{
	size_t i;

	if (bshas(s->prepainted, u))
		return;
	if (moverelated(s, u))
		return;
	if (!istrivial(s, u))
		return;

	assert(locmap[u]->list == &s->wlfreeze || locmap[u]->list == &s->wlsimp);
	if (wlfind(s->wlfreeze, s->nwlfreeze, u, &i))
		wldel(s, &s->wlfreeze, &s->nwlfreeze, i);
	wlput(&s->wlsimp, &s->nwlsimp, locmap[u]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4c0(%rdi), %rdi
callq 0xcada
testl %eax, %eax
jne 0xd2f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce7e
testl %eax, %eax
je 0xd307
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0xce32
testl %eax, %eax
je 0xd2f8
leaq 0x50b63(%rip), %rbp     # 0x5de80
movq (%rbp), %rax
movq (%rax,%r14,8), %r12
movq 0x8(%r12), %rax
leaq 0x480(%rbx), %r13
cmpq %r13, %rax
sete %cl
leaq 0x490(%rbx), %r15
cmpq %r15, %rax
sete %al
orb %cl, %al
je 0xd3a3
movq 0x480(%rbx), %rdi
movq 0x488(%rbx), %rsi
movq %rsp, %rcx
movq %r14, %rdx
callq 0xd1df
testl %eax, %eax
je 0xd380
leaq 0x488(%rbx), %rsi
movq (%rsp), %rdx
movq %r13, %rdi
callq 0xd20a
movq (%rbp), %rax
movq (%rax,%r14,8), %r12
addq $0x498, %rbx            # imm = 0x498
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xce63
leaq 0x20c30(%rip), %rdi     # 0x2dfda
leaq 0x20b13(%rip), %rsi     # 0x2dec4
leaq 0x20c63(%rip), %rcx     # 0x2e01b
movl $0x336, %edx            # imm = 0x336
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: freezemoves
static void
freezemoves(Isel *s, Loc *u)
{
	size_t i;
	Insn **ml;
	Insn *m;
	size_t nml;
	size_t idx;
	Loc *v;

	nml = nodemoves(s, u->reg.id, &ml);
	for (i = 0; i < nml; i++) {
		m = ml[i];
		if (getalias(s, m->args[0]->reg.id) == getalias(s, u->reg.id))
			v = locmap[getalias(s, m->args[1]->reg.id)];
		else
			v = locmap[getalias(s, m->args[0]->reg.id)];

		if (!mldel(&s->mactive, &s->nmactive, s->mactiveset, m))
			mldel(&s->wlmove, &s->nwlmove, s->wlmoveset, m);

		lappend(&s->mfrozen, &s->nmfrozen, m);
		if (!moverelated(s, v->reg.id) && istrivial(s, v->reg.id)) {
			if (!wlfind(s->wlfreeze, s->nwlfreeze, v->reg.id, &idx))
				die("Reg %zd not in freeze wl\n", v->reg.id);
			wldel(s, &s->wlfreeze, &s->nwlfreeze, idx);
			wlput(&s->wlsimp, &s->nwlsimp, v);
		}

	}
	lfree(&ml, &nml);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq %rsi, 0x50(%rsp)
movq 0x10(%rsi), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdx
callq 0xd21b
movq %rax, 0x58(%rsp)
movq %rax, 0x68(%rsp)
movq (%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x448(%r14), %rax
movq %rax, 0x40(%rsp)
leaq 0x450(%r14), %rax
movq %rax, 0x38(%rsp)
leaq 0x460(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x468(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x430(%r14), %rax
movq %rax, 0x30(%rsp)
leaq 0x438(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x480(%r14), %rbx
leaq 0x488(%r14), %r15
leaq 0x490(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x498(%r14), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
movq %r15, 0x20(%rsp)
cmpq %rbp, 0x58(%rsp)
je 0xd583
movq %rbx, %r15
movq 0x48(%rsp), %rax
movq (%rax,%rbp,8), %r13
movq 0x10(%r13), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa97a
movq %rax, %r12
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa97a
leaq 0x509cf(%rip), %rcx     # 0x5de80
movq (%rcx), %rbx
cmpq %rax, %r12
jne 0xd4cc
movq 0x18(%r13), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xa97a
movq %rax, %r12
movq (%rbx,%r12,8), %r12
movq 0x440(%r14), %rdx
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r13, %rcx
callq 0xd5b2
testl %eax, %eax
jne 0xd506
movq 0x458(%r14), %rdx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rcx
callq 0xd5b2
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %r13, %rdx
callq 0x29b2d
movq 0x10(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xce7e
testl %eax, %eax
movq %r15, %rbx
movq 0x20(%rsp), %r15
jne 0xd57b
movq %r14, %rdi
movq %r13, %rsi
callq 0xce32
testl %eax, %eax
je 0xd57b
movq (%rbx), %rdi
movq (%r15), %rsi
movq %r13, %rdx
leaq 0x60(%rsp), %rcx
callq 0xd1df
testl %eax, %eax
je 0xd5a1
movq 0x60(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd20a
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0xce63
incq %rbp
jmp 0xd46f
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x29cc7
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20aa9(%rip), %rdi     # 0x2e051
movq %r13, %rsi
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: mldel
static int
mldel(Insn ***ml, size_t *nml, Bitset *bs, Insn *m)
{
	size_t i;
	if (bshas(bs, m->uid)) {
		bsdel(bs, m->uid);
		for (i = 0; i < *nml; i++) {
			if (m == (*ml)[i]) {
				ldel(ml, nml, i);
				return 1;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rcx), %r13
movq %rdx, %rdi
movq %r13, %rsi
callq 0xcada
testl %eax, %eax
je 0xd5fe
movq %r12, %rdi
movq %r13, %rsi
callq 0x29f3e
movq (%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xd610
movq (%r15), %rsi
cmpq %r14, (%rsi,%rdx,8)
je 0xd602
incq %rdx
jmp 0xd5eb
xorl %eax, %eax
jmp 0xd610
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29bfa
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/ra.c
// Function: mapfind
static Loc *
mapfind(Isel *s, Htab *map, Loc *old)
{
	Loc *new;
	Loc *base;
	Loc *idx;
	regid id;

	if (!old)
		return NULL;

	new = NULL;
	if (old->type == Locreg) {
		id = getalias(s, old->reg.id);
		new = htget(map, locmap[id]);
	} else if (old->type == Locmem || old->type == Locmeml) {
		base = old->mem.base;
		idx = old->mem.idx;
		if (base)
			base = locmap[getalias(s, base->reg.id)];
		if (idx)
			idx = locmap[getalias(s, idx->reg.id)];
		base = mapfind(s, map, base);
		idx = mapfind(s, map, idx);
		if (base != old->mem.base || idx != old->mem.idx) {
			if (old->type == Locmem)
				new = locmems(old->mem.constdisp, base, idx, old->mem.scale, old->mode);
			else
				new = locmemls(old->mem.lbldisp, base, idx, old->mem.scale, old->mode);
		}
	}
	if (new)
		return new;
	return old;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xd6c0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd6c7
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %r13
testq %rax, %rax
je 0xd6f7
leaq 0x507d5(%rip), %rcx     # 0x5de80
movq (%rcx), %r12
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0xa97a
movq (%r12,%rax,8), %r12
jmp 0xd6fa
xorl %ebx, %ebx
jmp 0xd788
cmpl $0x2, %eax
jne 0xd767
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0xa97a
leaq 0x5079d(%rip), %rcx     # 0x5de80
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x2a3e8
jmp 0xd781
xorl %r12d, %r12d
testq %r13, %r13
je 0xd71c
leaq 0x5077a(%rip), %rax     # 0x5de80
movq (%rax), %rbp
movq 0x10(%r13), %rsi
movq %r15, %rdi
callq 0xa97a
movq (%rbp,%rax,8), %r13
jmp 0xd71f
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd674
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xd674
cmpq 0x28(%rbx), %r12
jne 0xd74a
cmpq 0x30(%rbx), %rax
je 0xd767
cmpl $0x3, (%rbx)
jne 0xd76b
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0x9e7c
jmp 0xd781
xorl %eax, %eax
jmp 0xd781
movq 0x10(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0x9edd
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/peep.c
// Function: peep
void
peep(Isel *s)
{
	size_t i;

	for (i = 0; i < s->nbb; i++) {
		deadcode(s, s->bb[i]);
		nopjmp(s, s->bb[i], i);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x20(%rdi), %rdi
pushq $0x1
popq %r14
xorl %r12d, %r12d
movq %rdi, 0x8(%rsp)
cmpq %rdi, %r12
je 0xd87f
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0xd874
movq 0x20(%r13), %rbp
xorl %ecx, %ecx
cmpq %rcx, %rbp
je 0xd803
movq 0x18(%r13), %rdx
movq (%rdx,%rcx,8), %rdx
incq %rcx
cmpl $0x34, 0x8(%rdx)
jne 0xd7e4
movq %rcx, 0x20(%r13)
movq %rcx, %rbp
jmp 0xd808
testq %rbp, %rbp
je 0xd874
movq 0x18(%r13), %rcx
movq -0x8(%rcx,%rbp,8), %rcx
cmpl $0x34, 0x8(%rcx)
jne 0xd874
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rsp)
cmpl $0x1, (%rcx)
jne 0xd874
movq %r14, %rcx
cmpq %rdi, %rcx
jae 0xd874
movq (%rax,%rcx,8), %r15
incq %rcx
testq %r15, %r15
je 0xd828
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
cmpq %rbx, 0x18(%rsp)
je 0xd874
movq 0x8(%r15), %rax
movq (%rax,%rbx,8), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x4230
movq 0x8(%rsp), %rdi
incq %rbx
testl %eax, %eax
jne 0xd844
decq %rbp
movq %rbp, 0x20(%r13)
incq %r12
incq %r14
jmp 0xd7bf
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: loadvar
Node *
loadvar(Simp *s, Node *n, Node *dst)
{
	Node *p, *f, *r, *e;

	if (isconstfn(n)) {
		if (dst)
			r = dst;
		else
			r = temp(s, n);
		f = getcode(s, n);
		p = addr(s, r, exprtype(n));
		assignat(s, p, Ptrsz, f);
		e = mkintlit(n->loc, 0);
		e->expr.type = tyintptr;
		assignat(s, p, 0, e);
	} else {
		r = n;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25902
testl %eax, %eax
je 0xd95f
testq %rbx, %rbx
jne 0xd8ff
movq %r14, %rdi
movq %r15, %rsi
callq 0xd96c
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0xd9da
movq %rax, %r12
movq %r15, %rdi
callq 0x1bf90
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xdab6
movq %rax, %r13
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0xdb74
movq (%r15), %rdi
xorl %esi, %esi
callq 0x1b6fc
movq 0x509e0(%rip), %rcx     # 0x5e328
movq %rcx, 0x20(%rax)
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xdb74
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: temp
static Node *
temp(Simp *simp, Node *e)
{
	Node *t, *dcl;

	assert(e->type == Nexpr);
	t = gentemp(e->loc, e->expr.type, &dcl);
	if (stacknode(e))
		declarelocal(simp, dcl);
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x8, 0x8(%rsi)
jne 0xd9bb
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x20(%rsi), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1bdcc
movq %rax, %r14
movq %r15, %rdi
callq 0xd8a8
testl %eax, %eax
je 0xd9ae
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe18a
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1f396(%rip), %rdi     # 0x2cd58
leaq 0x208eb(%rip), %rsi     # 0x2e2b4
leaq 0x208eb(%rip), %rcx     # 0x2e2bb
movl $0x11c, %edx            # imm = 0x11C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: getcode
static Node *
getcode(Simp *s, Node *n)
{
	Node *r, *p, *d;
	Type *ty;

	if (isconstfn(n)) {
		d = decls[n->expr.did];
		r = mkexpr(n->loc, Ovar, n->expr.args[0], NULL);
		r->expr.did = d->decl.did;
		r->expr.type = codetype(exprtype(n));
	} else {
		ty = tybase(exprtype(n));
		assert(ty->type == Tyfunc);
		p = addr(s, rval(s, n, NULL), codetype(ty));
		r = load(addk(p, Ptrsz));
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25902
testl %eax, %eax
je 0xda41
leaq 0x50f70(%rip), %rax     # 0x5e968
movq (%rax), %rax
movq (%rbx), %rdi
movq 0x38(%rbx), %rcx
movq (%rax,%rcx,8), %r15
movq 0x50(%rbx), %rax
movq (%rax), %rdx
pushq $0x33
popq %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x4edb
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x13, (%rax)
jne 0xda97
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe4f4
movq %rax, %rbx
movq %r15, %rdi
callq 0x4edb
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xdab6
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0xf7ee
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xf792
leaq 0x209bd(%rip), %rdi     # 0x2e45b
leaq 0x2080f(%rip), %rsi     # 0x2e2b4
leaq 0x209c2(%rip), %rcx     # 0x2e46e
movl $0x41e, %edx            # imm = 0x41E
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: addr
static Node *
addr(Simp *s, Node *a, Type *bt)
{
	Node *n;

	n = mkexpr(a->loc, Oaddr, a, NULL);
	if (!addressable(s, a))
		forcelocal(s, a);
	if (!bt)
		n->expr.type = mktyptr(a->loc, a->expr.type);
	else
		n->expr.type = mktyptr(a->loc, bt);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
pushq $0x12
popq %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %rbx
movl 0x8(%r15), %eax
cmpl $0xb, %eax
je 0xdaf7
cmpl $0x8, %eax
jne 0xdb31
movq %r15, %rdi
callq 0x1b5e6
cmpl $0x33, %eax
jne 0xdb31
movq 0x50(%r12), %rdi
movq %r15, %rsi
callq 0x2a517
testl %eax, %eax
jne 0xdb48
movq 0x48(%r12), %rdi
movq %r15, %rsi
callq 0x2a517
testl %eax, %eax
jne 0xdb48
movq 0x40(%r12), %rdi
movq %r15, %rsi
callq 0x2a517
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0xdb39
movq %r15, %rdi
callq 0xd8a8
testl %eax, %eax
jne 0xdb48
movq %r12, %rdi
movq %r15, %rsi
callq 0xe1fc
testq %r14, %r14
je 0xdb55
movq (%r15), %rdi
movq %r14, %rsi
jmp 0xdb5c
movq (%r15), %rdi
movq 0x20(%r15), %rsi
callq 0x2020c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: assignat
static Node *
assignat(Simp *s, Node *r, size_t off, Node *val)
{
	Node *pval, *pdst;
	Node *sz;
	Node *st;

	pdst = add(r, disp(val->loc, off));

	if (stacknode(val)) {
		sz = disp(val->loc, size(val));
		pval = addr(s, val, exprtype(val));
		st = mkexpr(val->loc, Oblit, pdst, pval, sz, NULL);
	} else {
		st = set(deref(pdst, val->expr.type), val);
	}
	append(s, st);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rcx), %rdi
movl %edx, %esi
callq 0xe335
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe2d4
movq %rax, %r12
movq %r15, %rdi
callq 0xd8a8
testl %eax, %eax
je 0xdbf0
movq %r15, %rdi
callq 0x10f54
movq (%r15), %rdi
movl %eax, %esi
callq 0xe335
movq %rax, %r13
movq %r15, %rdi
callq 0x1bf90
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdab6
movq (%r15), %rdi
pushq $0x46
popq %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1b718
jmp 0xdc07
movq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0xe3fb
movq %rax, %rdi
movq %r15, %rsi
callq 0xe34a
movq %r14, %rdi
movq %rax, %rsi
callq 0xe461
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: declarelocal
static void
declarelocal(Simp *s, Node *n)
{
	if (n->type == Nexpr)
		n = decls[n->decl.did];
	if (n->decl.isconst && n->decl.isextern)
		htput(s->globls, n, asmname(n));
	else if (stacknode(n))
		forcelocal(s, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, 0x8(%rsi)
jne 0xe1ac
leaq 0x507c7(%rip), %rax     # 0x5e968
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rbx
cmpb $0x0, 0x72(%rbx)
je 0xe1d9
cmpb $0x0, 0x74(%rbx)
je 0xe1d9
movq 0x40(%r14), %r14
movq %rbx, %rdi
callq 0x4f1a
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a22a
movq %rbx, %rdi
callq 0xd8a8
testl %eax, %eax
je 0xe1f4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe1fc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: forcelocal
static void
forcelocal(Simp *s, Node *n)
{
	assert(n->type == Ndecl || (n->type == Nexpr && exprop(n) == Ovar));
	s->stksz += size(n);
	s->stksz = align(s->stksz, min(size(n), Ptrsz));
	if (debugopt['i']) {
		dumpn(n, stdout);
		printf("declared at %zd, size = %zd\n", s->stksz, size(n));
	}
	htput(s->stkoff, n, itop(s->stksz));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
cmpl $0xb, %eax
je 0xe229
cmpl $0x8, %eax
jne 0xe2b5
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x33, %eax
jne 0xe2b5
movq %rbx, %rdi
callq 0x10f54
movq %rax, %r15
addq 0x58(%r14), %r15
movq %r15, 0x58(%r14)
movq %rbx, %rdi
callq 0x10f54
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x2ac08
movq %r15, %rdi
movq %rax, %rsi
callq 0x2ac13
movq %rax, 0x58(%r14)
leaq 0x4ff7b(%rip), %rcx     # 0x5e1e0
cmpb $0x0, 0x69(%rcx)
je 0xe2a1
movq 0x32d5e(%rip), %rax     # 0x40fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1201b
movq 0x58(%r14), %r15
movq %rbx, %rdi
callq 0x10f54
leaq 0x200a2(%rip), %rdi     # 0x2e332
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4140
movq 0x58(%r14), %rax
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a22a
leaq 0x2001a(%rip), %rdi     # 0x2e2d6
leaq 0x1fff1(%rip), %rsi     # 0x2e2b4
leaq 0x20048(%rip), %rcx     # 0x2e312
movl $0xab, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: add
static Node *
add(Node *a, Node *b)
{
	Node *n;

	assert(size(a) == size(b));
	n = mkexpr(a->loc, Oadd, a, b, NULL);
	n->expr.type = a->expr.type;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x10f54
movq %rax, %r15
movq %r14, %rdi
callq 0x10f54
cmpq %rax, %r15
jne 0xe318
movq (%rbx), %rdi
pushq $0x2
popq %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20030(%rip), %rdi     # 0x2e34f
leaq 0x1ff8e(%rip), %rsi     # 0x2e2b4
leaq 0x20035(%rip), %rcx     # 0x2e362
pushq $0x69
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: set
static Node *
set(Node *a, Node *b)
{
	Node *n;

	assert(a != NULL && b != NULL);
	assert(exprop(a) == Ovar || exprop(a) == Oderef);
	if (tybase(exprtype(a))->type == Tyvoid)
		return a;

	n = mkexpr(a->loc, Oset, a, b, NULL);
	n->expr.type = exprtype(a);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe3bd
movq %rsi, %r14
testq %rsi, %rsi
je 0xe3bd
movq %rdi, %rbx
callq 0x1b5e6
cmpl $0x33, %eax
je 0xe375
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x13, %eax
jne 0xe3dc
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x1, (%rax)
je 0xe3b2
movq (%rbx), %rdi
pushq $0x40
popq %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ffb8(%rip), %rdi     # 0x2e37c
leaq 0x1fee9(%rip), %rsi     # 0x2e2b4
leaq 0x1ffc1(%rip), %rcx     # 0x2e393
movl $0xef, %edx
callq 0x4180
leaq 0x1ffca(%rip), %rdi     # 0x2e3ad
leaq 0x1feca(%rip), %rsi     # 0x2e2b4
leaq 0x1ffa2(%rip), %rcx     # 0x2e393
movl $0xf0, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: deref
static Node *
deref(Node *a, Type *t)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	if (t)
		n->expr.type = t;
	else
		n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0xe442
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x13
popq %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r15
testq %rbx, %rbx
jne 0xe435
movq 0x20(%r14), %rdi
callq 0xe4c7
movq %rax, %rbx
movq %rbx, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ff8d(%rip), %rdi     # 0x2e3d6
leaq 0x1fe64(%rip), %rsi     # 0x2e2b4
leaq 0x1ff9b(%rip), %rcx     # 0x2e3f2
movl $0xe1, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: append
static void
append(Simp *s, Node *n)
{
	if (debugopt['S'])
		dumpn(n, stdout);
        assert(n->type != Ndecl);
	lappend(&s->stmts, &s->nstmts, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4fd6e(%rip), %rax     # 0x5e1e0
cmpb $0x0, 0x53(%rax)
je 0xe48a
movq 0x32b51(%rip), %rax     # 0x40fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1201b
cmpl $0xb, 0x8(%rbx)
je 0xe4aa
leaq 0x8(%r14), %rdi
addq $0x10, %r14
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29b2d
leaq 0x1ff7d(%rip), %rdi     # 0x2e42e
leaq 0x1fdfc(%rip), %rsi     # 0x2e2b4
leaq 0x1ff80(%rip), %rcx     # 0x2e43f
pushq $0x4d
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: load
static Node *
load(Node *a)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0xf7cf
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x13
popq %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0xe4c7
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ec00(%rip), %rdi     # 0x2e3d6
leaq 0x1ead7(%rip), %rsi     # 0x2e2b4
leaq 0x1ee39(%rip), %rcx     # 0x2e61d
movl $0xd6, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: idxaddr
static Node *
idxaddr(Simp *s, Node *seq, Node *idx)
{
	Node *a, *t, *u, *v, *w; /* temps */
	Node *r; /* result */
	Type *ty, *seqty;
	size_t sz;

	a = rval(s, seq, NULL);
	seqty = tybase(exprtype(seq));
	ty = seqty->sub[0];
	if (seqty->type == Tyarray) {
		t = addr(s, a, ty);
		w = seqty->asize;
	} else if (seqty->type == Tyslice) {
		t = load(addr(s, a, mktyptr(seq->loc, ty)));
		w = slicelen(s, a);
	} else {
		die("can't index type %s", tystr(seq->expr.type));
	}
	assert(exprtype(t)->type == Typtr);
	u = rval(s, idx, NULL);
	u = ptrsized(s, u);
	checkidx(s, Olt, w, u);
	sz = tysize(ty);
	v = mul(u, disp(seq->loc, sz));
	r = add(t, v);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xe4f4
movq %rax, %rbp
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
movq %rax, %r15
movq 0x68(%rax), %rax
movq (%rax), %r12
movl (%r15), %eax
cmpl $0x14, %eax
je 0xf882
cmpl $0x15, %eax
jne 0xf940
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xdab6
movq %rax, %r13
movq 0x88(%r15), %rbp
jmp 0xf8b4
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x2020c
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xdab6
movq %rax, %rdi
callq 0xf792
movq %rax, %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x100e5
movq %rax, %rbp
movq %r13, %rdi
callq 0x1bf90
cmpl $0x12, (%rax)
jne 0xf921
movq %r14, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xe4f4
movq %rax, %rdi
callq 0xff7c
movq %rax, %r15
pushq $0x1b
popq %rsi
movq %r14, %rdi
movq %rbp, %rdx
movq %rax, %rcx
callq 0xffd0
movq %r12, %rdi
callq 0x10d64
movq (%rbx), %rdi
movl %eax, %esi
callq 0xe335
movq %r15, %rdi
movq %rax, %rsi
callq 0x100c1
movq %r13, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe2d4
leaq 0x1ec22(%rip), %rdi     # 0x2e54a
leaq 0x1e985(%rip), %rsi     # 0x2e2b4
leaq 0x1ec2f(%rip), %rcx     # 0x2e565
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x4180
movq 0x20(%rbx), %rdi
callq 0x21009
leaq 0x1ebe6(%rip), %rdi     # 0x2e536
movq %rax, %rsi
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: seqlen
static Node *
seqlen(Simp *s, Node *n, Type *ty)
{
	Node *t, *r;

        r = NULL;
	if (exprtype(n)->type == Tyslice) {
		t = slicelen(s, n);
		r = simpcast(s, t, ty);
	} else if (exprtype(n)->type == Tyarray) {
		t = exprtype(n)->asize;
                if (t)
                    r = simpcast(s, t, ty);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1bf90
cmpl $0x14, (%rax)
jne 0xf988
movq %r14, %rdi
movq %r15, %rsi
callq 0x100e5
movq %r14, %rdi
movq %rax, %rsi
jmp 0xf9ac
movq %r15, %rdi
callq 0x1bf90
cmpl $0x15, (%rax)
jne 0xf9b6
movq %r15, %rdi
callq 0x1bf90
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0xf9b6
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf9be
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: simpblob
static Node *
simpblob(Simp *s, Node *blob)
{
	Node *r, *d;

	r = geninitdecl(blob, exprtype(blob), &d);
	htput(s->globls, d, asmname(d));
	lappend(&s->blobs, &s->nblobs, d);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1bf90
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1018a
movq %rax, %r14
movq 0x40(%rbx), %r12
movq (%r15), %r13
movq %r13, %rdi
callq 0x4f1a
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2a22a
leaq 0x30(%rbx), %rdi
addq $0x38, %rbx
movq (%r15), %rdx
movq %rbx, %rsi
callq 0x29b2d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/6/simp.c
// Function: assign
static Node *
assign(Simp *s, Node *lhs, Node *rhs)
{
	Node *t, *u, *v, *r;

	t = lval(s, lhs);
	u = rval(s, rhs, t);

	if (tybase(exprtype(lhs))->type == Tyvoid)
		return u;

	/* hack: we're assigning to lhs, but blitting shit over doesn't
	 * trigger that */
	if (stacknode(lhs))
		def(s, lhs);
	/* if we stored the result into t, rval() should return that,
	 * so we know our work is done. */
	if (u == t) {
		r = t;
	} else if (stacknode(lhs)) {
		t = addr(s, t, exprtype(lhs));
		u = addr(s, u, exprtype(lhs));
		v = disp(lhs->loc, size(lhs));
		r = mkexpr(lhs->loc, Oblit, t, u, v, NULL);
		r->expr.type = exprtype(lhs);
	} else {
		r = set(t, u);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xfcfb
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe4f4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x1, (%rax)
je 0xfcd6
movq %rbx, %rdi
callq 0xd8a8
testl %eax, %eax
je 0xfc50
movq %r15, %rdi
movq %rbx, %rsi
callq 0x102af
cmpq %r12, %r14
je 0xfcd3
movq %rbx, %rdi
callq 0xd8a8
testl %eax, %eax
je 0xfce5
movq %rbx, %rdi
callq 0x1bf90
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xdab6
movq %rax, %r12
movq %rbx, %rdi
callq 0x1bf90
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xdab6
movq %rax, %r14
movq %rbx, %rdi
callq 0x10f54
movq (%rbx), %rdi
movl %eax, %esi
callq 0xe335
movq (%rbx), %rdi
pushq $0x46
popq %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, 0x20(%r14)
jmp 0xfcd6
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe34a