LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: selspill
static void
selspill(Isel *s)
{
	size_t i;
	Loc *m;

	/* FIXME: pick a better heuristic for spilling */
	m = NULL;
	for (i = 0; i < s->nwlspill; i++) {
		if (!bshas(s->shouldspill, s->wlspill[i]->reg.id))
			continue;
		m = s->wlspill[i];
		wldel(s, &s->wlspill, &s->nwlspill, i);
		break;
	}
	if (!m) {
		for (i = 0; i < s->nwlspill; i++) {
			if (bshas(s->neverspill, s->wlspill[i]->reg.id)) {
				continue;
			}
			m = s->wlspill[i];
			wldel(s, &s->wlspill, &s->nwlspill, i);
			break;
		}
	}
	assert(m != NULL);
	wlput(&s->wlsimp, &s->nwlsimp, m);
	freezemoves(s, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x478(%rcx), %rax
jae 0x12f58
movq -0x8(%rbp), %rax
movq 0x3f0(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x470(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x12f0b
jmp 0x12f47
movq -0x8(%rbp), %rax
movq 0x470(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x470, %rsi            # imm = 0x470
movq -0x8(%rbp), %rdx
addq $0x478, %rdx            # imm = 0x478
movq -0x10(%rbp), %rcx
callq 0x14b80
jmp 0x12f58
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12ecc
cmpq $0x0, -0x18(%rbp)
jne 0x12ff9
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x478(%rcx), %rax
jae 0x12ff7
movq -0x8(%rbp), %rax
movq 0x3f8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x470(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x12faa
jmp 0x12fe6
movq -0x8(%rbp), %rax
movq 0x470(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x470, %rsi            # imm = 0x470
movq -0x8(%rbp), %rdx
addq $0x478, %rdx            # imm = 0x478
movq -0x10(%rbp), %rcx
callq 0x14b80
jmp 0x12ff7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12f6b
jmp 0x12ff9
cmpq $0x0, -0x18(%rbp)
je 0x13002
jmp 0x13021
leaq 0x3adcf(%rip), %rdi     # 0x4ddd8
leaq 0x3ac21(%rip), %rsi     # 0x4dc31
movl $0x425, %edx            # imm = 0x425
leaq 0x3adc6(%rip), %rcx     # 0x4dde2
callq 0x6160
movq -0x8(%rbp), %rdi
addq $0x490, %rdi            # imm = 0x490
movq -0x8(%rbp), %rsi
addq $0x498, %rsi            # imm = 0x498
movq -0x18(%rbp), %rdx
callq 0x14590
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x155c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: rewrite
static void
rewrite(Isel *s, Loc **aliasmap)
{
	size_t i;

	s->spillslots = mkht(ptrhash, ptreq);
	/* set up stack locations for all spilled registers. */
	for (i = 0; bsiter(s->spilled, &i); i++)
		addspill(s, locmap[i]);

	/* rewrite instructions using them */
	for (i = 0; i < s->nbb; i++)
		rewritebb(s, s->bb[i], aliasmap);
	htfree(s->spillslots);
	bsclear(s->spilled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x36799(%rip), %rdi     # 0x49b00
leaq 0x367f2(%rip), %rsi     # 0x49b60
callq 0x48fe0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x133c8
movq -0x8(%rbp), %rdi
leaq 0x695f6(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x158c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13386
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x13409
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
callq 0x159c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x133d0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x490a0
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
callq 0x48760
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: delnops
static void
delnops(Isel *s)
{
	Insn *insn;
	Asmbb *bb;
	Insn **new;
	size_t nnew;
	size_t i, j;

	for (i = 0; i < s->nbb; i++) {
		if (!s->bb[i])
			continue;
		new = NULL;
		nnew = 0;
		bb = s->bb[i];
		for (j = 0; j < bb->ni; j++) {
			insn = bb->il[j];
			if (ismove(insn) && insn->args[0]->reg.colour == insn->args[1]->reg.colour)
				continue;
			lappend(&new, &nnew, insn);
		}
		lfree(&bb->il, &bb->ni);
		bb->il = new;
		bb->ni = nnew;
	}
	if (debugopt['r'])
		dumpasm(s, stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x13541
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1346e
jmp 0x13530
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x13503
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14000
cmpl $0x0, %eax
je 0x134e4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jne 0x134e4
jmp 0x134f5
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48290
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1349a
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x48580
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x13444
leaq 0x697b8(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x72(%rax)
je 0x13561
movq -0x8(%rbp), %rdi
movq 0x4ba77(%rip), %rax     # 0x5efd0
movq (%rax), %rsi
callq 0x12810
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x3d0(%rcx), %rax
jae 0x135bb
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6040
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x13584
movq -0x8(%rbp), %rax
movq 0x3b0(%rax), %rdi
callq 0x6040
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rdi
callq 0x6040
movq -0x8(%rbp), %rax
movq 0x3c0(%rax), %rdi
callq 0x6040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x42206(%rip), %rax     # 0x55825
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3a56a(%rip), %rsi     # 0x4db9c
movb $0x0, %al
callq 0x6230
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x136b6
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x3f441(%rip), %rsi     # 0x52a9b
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x78, %edx
callq 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
leaq 0x3a50d(%rip), %rsi     # 0x4dba3
movb $0x0, %al
callq 0x6230
leaq 0x41d18(%rip), %rax     # 0x553bc
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13641
movq -0x8(%rbp), %rdi
leaq 0x3b318(%rip), %rsi     # 0x4e9d9
movb $0x0, %al
callq 0x6230
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3a6b4(%rip), %rsi     # 0x4de1b
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
leaq 0x69227(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x78, %edx
callq 0x8fe0
movq -0x8(%rbp), %rdi
leaq 0x3a687(%rip), %rsi     # 0x4de20
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
leaq 0x691f5(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x78, %edx
callq 0x8fe0
movq -0x8(%rbp), %rdi
leaq 0x3a3eb(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4202e(%rip), %rax     # 0x55825
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48a30
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x13867
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x13857
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3a5e0(%rip), %rsi     # 0x4de25
movb $0x0, %al
callq 0x6230
leaq 0x41b69(%rip), %rax     # 0x553bc
movq %rax, -0x18(%rbp)
jmp 0x13859
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13803
movq -0x8(%rbp), %rdi
leaq 0x3a344(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x41f8e(%rip), %rax     # 0x55825
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48a30
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x13923
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x13913
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3f1ba(%rip), %rsi     # 0x52a9b
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
leaq 0x690ad(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x78, %edx
callq 0x8fe0
leaq 0x41aad(%rip), %rax     # 0x553bc
movq %rax, -0x18(%rbp)
jmp 0x13915
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x138a3
movq -0x8(%rbp), %rdi
leaq 0x3a288(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: getmappedalias
static regid
getmappedalias(Loc **aliasmap, size_t nreg, regid id)
{
	/*
	 * if we get called from rewrite(), we can get a register that
	 * we just created, with an id bigger than the number of entrie
	 * in the alias map. We should just return its id in that case.
	 */
	while (id < nreg) {
		if (!aliasmap[id])
			break;
		id = aliasmap[id]->reg.id;
	};
	return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x13981
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1396b
jmp 0x13981
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13950
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: udcalc
static void
udcalc(Asmbb *bb)
{
	regid   u[Nreg], d[Nreg];
	size_t nu, nd;
	size_t i, j;

	bb->use = bsclear(bb->use);
	bb->def = bsclear(bb->def);
	for (i = 0; i < bb->ni; i++) {
		nu = uses(bb->il[i], u);
		nd = defs(bb->il[i], d);
		for (j = 0; j < nu; j++)
			if (!bshas(bb->def, u[j]))
				bsput(bb->use, u[j]);
		for (j = 0; j < nd; j++)
			bsput(bb->def, d[j]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x690, %rsp            # imm = 0x690
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x48760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x48760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq $0x0, -0x688(%rbp)
movq -0x688(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x13b0d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x688(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x340(%rbp), %rsi
callq 0x13b20
movq %rax, -0x678(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x688(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x670(%rbp), %rsi
callq 0x13d80
movq %rax, -0x680(%rbp)
movq $0x0, -0x690(%rbp)
movq -0x690(%rbp), %rax
cmpq -0x678(%rbp), %rax
jae 0x13aa9
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x690(%rbp), %rax
movq -0x340(%rbp,%rax,8), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x13a93
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x690(%rbp), %rax
movq -0x340(%rbp,%rax,8), %rsi
callq 0x48a50
jmp 0x13a95
movq -0x690(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x690(%rbp)
jmp 0x13a46
movq $0x0, -0x690(%rbp)
movq -0x690(%rbp), %rax
cmpq -0x680(%rbp), %rax
jae 0x13af4
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x690(%rbp), %rax
movq -0x670(%rbp,%rax,8), %rsi
callq 0x48a50
movq -0x690(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x690(%rbp)
jmp 0x13ab4
jmp 0x13af6
movq -0x688(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x688(%rbp)
jmp 0x139da
addq $0x690, %rsp            # imm = 0x690
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x13e61
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x5a0e5(%rip), %rax     # 0x6dea0
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rcx, %rax
movq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x13dd4
jmp 0x13e61
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x5a0bc(%rip), %rax     # 0x6dea0
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpl $0x2, (%rax)
jne 0x13e4e
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x13f80
cmpl $0x0, %eax
jne 0x13e4c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x13e4e
jmp 0x13e50
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13da0
movq $0x0, -0x18(%rbp)
cmpq $0x66, -0x18(%rbp)
jae 0x13ef4
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x5a01c(%rip), %rax     # 0x6dea0
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rcx, %rax
movq -0x18(%rbp), %rcx
cmpl $0x0, 0x19c(%rax,%rcx,4)
jne 0x13e9e
jmp 0x13ef4
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x59ff2(%rip), %rax     # 0x6dea0
imulq $0x338, %rcx, %rcx      # imm = 0x338
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movl 0x19c(%rax,%rcx,4), %edi
callq 0xffc0
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13e69
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/../util/util.h
// Function: bshas
static inline int bshas(Bitset *bs, size_t elt)
{
	size_t eltidx, eltshift;

	if (elt >= bs->nchunks * 8 * sizeof(size_t))
		return 0;
	eltidx = elt / (8 * sizeof(size_t));
	eltshift = elt % (8 * sizeof(size_t));
	return (bs->chunks[eltidx] & (1ULL << eltshift)) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
shlq $0x3, %rcx
cmpq %rcx, %rax
jb 0x13f2d
movl $0x0, -0x4(%rbp)
jmp 0x13f76
movq -0x18(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: isfixreg
static int
isfixreg(Loc *l)
{
	if (l->reg.colour == Resp)
		return 1;
	if (l->reg.colour == Rebp)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2b, 0x18(%rax)
jne 0x13f9b
movl $0x1, -0x4(%rbp)
jmp 0x13fb5
movq -0x10(%rbp), %rax
cmpl $0x2c, 0x18(%rax)
jne 0x13fae
movl $0x1, -0x4(%rbp)
jmp 0x13fb5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x14094
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x136d0
cmpl $0x0, %eax
je 0x14099
jmp 0x14209
cmpq $0x3c, -0x10(%rbp)
je 0x140ae
cmpq $0x3b, -0x10(%rbp)
je 0x140ae
cmpq $0x65, -0x10(%rbp)
jne 0x140b3
jmp 0x14209
cmpq $0x3c, -0x18(%rbp)
je 0x140c8
cmpq $0x3b, -0x18(%rbp)
je 0x140c8
cmpq $0x65, -0x18(%rbp)
jne 0x140cd
jmp 0x14209
leaq 0x688cc(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10fb0
movl %eax, -0x1c(%rbp)
leaq 0x688b2(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10fb0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x1410c
jmp 0x14209
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14143
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14143
jmp 0x14209
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14210
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x14210
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x141b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14300
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x14400
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x3d8(%rax), %rax
movq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x14209
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x14300
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14400
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x3d8(%rax), %rax
movq -0x18(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
imulq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x3d0(%rax), %rax
imulq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq 0x3b0(%rax), %rax
movq -0x20(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq 0x3b0(%rax), %rax
movq -0x28(%rbp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x136d0
cmpl $0x0, %eax
je 0x142d8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x136d0
cmpl $0x0, %eax
je 0x142d8
jmp 0x142f7
leaq 0x39997(%rip), %rdi     # 0x4dc76
leaq 0x3994b(%rip), %rsi     # 0x4dc31
movl $0x16c, %edx            # imm = 0x16C
leaq 0x399ad(%rip), %rcx     # 0x4dc9f
callq 0x6160
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x3c0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x3c8(%rcx), %rcx
movq -0x10(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x143ae
movq -0x8(%rbp), %rax
movq 0x3c8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
shlq %rdx
addq $0x1, %rdx
movq -0x8(%rbp), %rax
movq 0x3c8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x3c8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
shlq $0x3, %rsi
callq 0x48240
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x3c0(%rcx), %rcx
movq -0x10(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x3c0(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x1443f
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x14478
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x1446a
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x14476
movl $0x1, -0x4(%rbp)
jmp 0x14518
jmp 0x14478
movq $0x0, -0x40(%rbp)
cmpq $0x7, -0x40(%rbp)
jae 0x14511
movq -0x28(%rbp), %rcx
leaq 0x6783a(%rip), %rax     # 0x7bcd0
movslq (%rax,%rcx,4), %rcx
leaq 0x674df(%rip), %rax     # 0x7b980
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x144fe
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x67800(%rip), %rax     # 0x7bcd0
movslq (%rax,%rcx,4), %rcx
leaq 0x674a5(%rip), %rax     # 0x7b980
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edx
callq 0x136d0
cmpl $0x0, %eax
je 0x144fe
movl $0x0, -0x4(%rbp)
jmp 0x14518
jmp 0x14500
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x14480
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x408(%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x14690
movq -0x10(%rbp), %rax
movq 0x440(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14641
movl $0x1, -0x4(%rbp)
jmp 0x14697
movq -0x10(%rbp), %rax
movq 0x458(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x400(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x1467d
movl $0x1, -0x4(%rbp)
jmp 0x14697
jmp 0x1467f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x145e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: adjavail
static int
adjavail(Isel *s, regid r)
{
	if (locmap[r]->list == &s->selstk)
		return 0;
	if (bshas(s->coalesced, r))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x682e9(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x4a0, %rcx            # imm = 0x4A0
cmpq %rcx, %rax
jne 0x146df
movl $0x0, -0x4(%rbp)
jmp 0x14708
movq -0x10(%rbp), %rax
movq 0x4b0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14701
movl $0x0, -0x4(%rbp)
jmp 0x14708
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x14bd0
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x14af0
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rdi
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x14a04
jmp 0x14adf
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x450(%rcx), %rax
jae 0x14add
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x448(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x14aca
movq -0x8(%rbp), %rdi
addq $0x448, %rdi            # imm = 0x448
movq -0x8(%rbp), %rsi
addq $0x450, %rsi            # imm = 0x450
movq -0x20(%rbp), %rdx
callq 0x48420
movq -0x8(%rbp), %rdi
addq $0x460, %rdi            # imm = 0x460
movq -0x8(%rbp), %rsi
addq $0x468, %rsi            # imm = 0x468
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x48290
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rdi
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x48af0
movq -0x8(%rbp), %rax
movq 0x458(%rax), %rdi
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x48a50
jmp 0x14acc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14a0c
jmp 0x14adf
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x149cd
movq -0x28(%rbp), %rdi
callq 0x6040
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: wlfind
static int
wlfind(Loc **wl, size_t nwl, regid v, size_t *idx)
{
	size_t i;

	for (i = 0; i < nwl; i++) {
		if (wl[i]->reg.id == v) {
			*idx = i;
			return 1;
		}
	}
	*idx = -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x14b60
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x14b50
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x14b72
jmp 0x14b52
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x14b1c
movq -0x28(%rbp), %rax
movq $-0x1, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
shlq $0x3, %rdi
callq 0x6280
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x408(%rcx), %rcx
movq -0x10(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x14cca
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x14c85
movq -0x8(%rbp), %rax
movq 0x458(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14cb7
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x14cb9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14c14
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14d0e
jmp 0x14e21
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x145d0
cmpl $0x0, %eax
je 0x14d25
jmp 0x14e21
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14530
cmpl $0x0, %eax
jne 0x14d3c
jmp 0x14e21
leaq 0x67c5d(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x480, %rcx            # imm = 0x480
cmpq %rcx, %rax
je 0x14d88
leaq 0x67c37(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x490, %rcx            # imm = 0x490
cmpq %rcx, %rax
jne 0x14d8a
jmp 0x14da9
leaq 0x38fb6(%rip), %rdi     # 0x4dd47
leaq 0x38e99(%rip), %rsi     # 0x4dc31
movl $0x336, %edx            # imm = 0x336
leaq 0x38fe4(%rip), %rcx     # 0x4dd88
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x480(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x488(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x14b00
cmpl $0x0, %eax
je 0x14df4
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x480, %rsi            # imm = 0x480
movq -0x8(%rbp), %rdx
addq $0x488, %rdx            # imm = 0x488
movq -0x18(%rbp), %rcx
callq 0x14b80
movq -0x8(%rbp), %rdi
addq $0x490, %rdi            # imm = 0x490
movq -0x8(%rbp), %rsi
addq $0x498, %rsi            # imm = 0x498
leaq 0x67b8f(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x14590
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: constrained
static int
constrained(Isel *s, regid u, regid v)
{
	size_t i;

	if (bshas(s->prepainted, v))
		return 1;
	if (bshas(s->prepainted, u))
		for (i = 0; i < Nmode; i++)
			if (regmap[colourmap[u]][i] && gbhasedge(s, regmap[colourmap[u]][i], v))
				return 1;
	return gbhasedge(s, u, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14e69
movl $0x1, -0x4(%rbp)
jmp 0x14f23
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x14f0f
movq $0x0, -0x28(%rbp)
cmpq $0x7, -0x28(%rbp)
jae 0x14f0d
movq -0x18(%rbp), %rcx
leaq 0x66e30(%rip), %rax     # 0x7bcd0
movslq (%rax,%rcx,4), %rcx
leaq 0x66ad5(%rip), %rax     # 0x7b980
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x14efd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x66e05(%rip), %rax     # 0x7bcd0
movslq (%rax,%rcx,4), %rcx
leaq 0x66aaa(%rip), %rax     # 0x7b980
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x136d0
cmpl $0x0, %eax
je 0x14efd
movl $0x1, -0x4(%rbp)
jmp 0x14f23
jmp 0x14eff
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14e8e
jmp 0x14f0f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x136d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: combinable
static int
combinable(Isel *s, regid u, regid v)
{
	regid t;
	size_t i;

	/* Regs of different modes can't be combined as things stand.
	 * In principle they should be combinable, but it confused the
	 * whole mode dance. */
	if (locmap[u]->mode != locmap[v]->mode)
		return 0;
	/* if u isn't prepainted, can we conservatively coalesce? */
	if (!bshas(s->prepainted, u) && conservative(s, u, v))
		return 1;

	/* if it is, are the adjacent nodes ok to combine with this? */
	for (i = 0; i < s->ngadj[v]; i++) {
		t = s->gadj[v][i];
		if (adjavail(s, t) && !ok(s, t, u))
			return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x67a55(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
leaq 0x67a40(%rip), %rcx     # 0x7c9a0
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x4(%rcx), %eax
je 0x14f7c
movl $0x0, -0x4(%rbp)
jmp 0x1503f
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x14fb7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x153e0
cmpl $0x0, %eax
je 0x14fb7
movl $0x1, -0x4(%rbp)
jmp 0x1503f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x3c0(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x15038
movq -0x10(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x146a0
cmpl $0x0, %eax
je 0x15028
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15540
cmpl $0x0, %eax
jne 0x15028
movl $0x0, -0x4(%rbp)
jmp 0x1503f
jmp 0x1502a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x14fbf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: conservative
static int
conservative(Isel *s, regid u, regid v)
{
	int k;
	size_t i;
	regid n;

	k = 0;
	for (i = 0; i < s->ngadj[u]; i++) {
		n = s->gadj[u][i];
		if (adjavail(s, n) && !istrivial(s, n))
			k++;
	}
	for (i = 0; i < s->ngadj[v]; i++) {
		n = s->gadj[v][i];
		if (adjavail(s, n) && !istrivial(s, n))
			k++;
	}
	return k < _K[rclass(locmap[u])];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x3c0(%rcx), %rcx
movq -0x10(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x15478
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x146a0
cmpl $0x0, %eax
je 0x15468
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14530
cmpl $0x0, %eax
jne 0x15468
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1546a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15403
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x3c0(%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x154f5
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x146a0
cmpl $0x0, %eax
je 0x154e5
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14530
cmpl $0x0, %eax
jne 0x154e5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x154e7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15480
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq 0x6749e(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10fb0
movl %eax, %ecx
movl -0x34(%rbp), %eax
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x66986(%rip), %rcx     # 0x7bea8
cmpl (%rcx,%rdx,4), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x158a3
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x48af0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x158a1
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x30(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x15891
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x48420
movl $0x1, -0x4(%rbp)
jmp 0x158aa
jmp 0x15893
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15855
jmp 0x158a3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: addspill
static void
addspill(Isel *s, Loc *l)
{
	s->stksz->lit += modesize[l->mode];
	s->stksz->lit = align(s->stksz->lit, modesize[l->mode]);
	if (debugopt['r']) {
		printf("spill ");
		dbglocprint(stdout, l, 'x');
		printf(" to %zd(%%rbp)\n", s->stksz->lit);
	}
	htput(s->spillslots, itop(l->reg.id), itop(s->stksz->lit));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x66590(%rip), %rax     # 0x7be70
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x66560(%rip), %rax     # 0x7be70
movq (%rax,%rcx,8), %rsi
callq 0x4a5b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rcx, 0x10(%rax)
leaq 0x673d1(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x72(%rax)
je 0x15975
leaq 0x384c8(%rip), %rdi     # 0x4de04
movb $0x0, %al
callq 0x6120
movq 0x49686(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x78, %edx
callq 0x8fe0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x3849d(%rip), %rdi     # 0x4de0b
movb $0x0, %al
callq 0x6120
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15f40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x15f40
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: nopmov
static int
nopmov(Isel *s, Insn *insn)
{
	if (insn->op != Imov)
		return 0;
	if (insn->args[0]->type != Locreg || insn->args[1]->type != Locreg)
		return 0;
	/* Prepainted register moves need to be kept live to avoid coalescing over them */
	return insn->args[0]->reg.id == insn->args[1]->reg.id && !bshas(s->prepainted, insn->args[0]->reg.id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x15fe3
movl $0x0, -0x4(%rbp)
jmp 0x16057
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x15ffd
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, (%rax)
je 0x16006
movl $0x0, -0x4(%rbp)
jmp 0x16057
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rbp)
jne 0x1604c
movq -0x10(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x13f00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq