LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: memloc
static Loc *
memloc(Isel *s, Node *e, Mode m)
{
	Node **args;
	Loc *l, *b, *o; /* location, base, offset */
	int scale;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rsi), %r13
movq %rsi, %rdi
callq 0x1d422
cmpl $0x2, %eax
jne 0x8fc0
movq (%r13), %rsi
movq %r14, %rdi
callq 0x775b
movq %rax, %r15
movq 0x8(%r13), %r12
addq $0x8, %r13
movq %r12, %rdi
callq 0x1d422
cmpl $0x4, %eax
jne 0x8fe2
movq 0x50(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x8fe2
movq 0x50(%r12), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8fe2
cmpl $0x2, 0x18(%rax)
jne 0x8fe2
movl 0x30(%rax), %ebp
cmpl $0x8, %ebp
ja 0x8fe2
movl $0x114, %eax            # imm = 0x114
btl %ebp, %eax
jae 0x8fe2
movq (%r13), %rax
movq 0x50(%rax), %r13
jmp 0x8fe7
movq %r14, %rdi
movq %r15, %rsi
callq 0x775b
cmpl $0x2, (%rax)
je 0x8fdb
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e9c
xorl %edi, %edi
movq %rax, %rsi
jmp 0x901e
movl $0x1, %ebp
movq (%r13), %rsi
movq %r14, %rdi
callq 0x775b
movq %rax, %r12
cmpl $0x2, (%r15)
je 0x900a
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e9c
movq %rax, %r15
movl (%r12), %eax
cmpl $0x5, %eax
jne 0x9029
movl %ebp, %edi
imulq 0x10(%r12), %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0xa973
jmp 0x9066
cmpl $0x2, (%r15)
je 0x9041
movq %r14, %rdi
movq %r15, %rsi
callq 0x8e9c
movq %rax, %r15
movl (%r12), %eax
cmpl $0x2, %eax
je 0x9054
movq %r14, %rdi
movq %r12, %rsi
callq 0x8e9c
movq %rax, %r12
xorl %edi, %edi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0xa9b8
testq %rax, %rax
je 0x907a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2de81(%rip), %rdi     # 0x36f02
leaq 0x279ee(%rip), %rsi     # 0x30a76
leaq 0x27ab7(%rip), %rcx     # 0x30b46
movl $0x1d3, %edx            # imm = 0x1D3
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: selcjmp
static void
selcjmp(Isel *s, Node *n, Node **args)
{
	Loc *a, *b;
	Loc *l1, *l2;
	AsmOp cond, jmp;

	cond = reloptab[exprop(args[0])].test;
	jmp = reloptab[exprop(args[0])].jmp;
	/* if we have a cond, we're knocking off the redundant test,
	 * and want to eval the children */
	if (cond) {
		a = selexpr(s, args[0]->expr.args[0]);
		if (args[0]->expr.nargs == 2)
			b = selexpr(s, args[0]->expr.args[1]);
		else
			b = a;
		a = newr(s, a);
	} else {
		cond = Itest;
		jmp = Ijnz;
		b = newr(s, selexpr(s, args[0])); /* cond */
		a = b;
	}

	/* the jump targets will always be evaluated the same way */
	l1 = loclbl(args[1]); /* if true */
	l2 = loclbl(args[2]); /* if false */

	g(s, cond, b, a, NULL);
	g(s, jmp, l1, NULL);
	g(s, Ijmp, l2, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1d422
movl %eax, %eax
leaq (%rax,%rax,2), %rax
leaq 0x3b1b1(%rip), %r15     # 0x44270
movl (%r15,%rax,4), %ebp
movq (%r14), %rdi
callq 0x1d422
movq (%r14), %rsi
testl %ebp, %ebp
je 0x912a
movl %ebp, 0x4(%rsp)
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%r15,%rax,4), %ebp
movq 0x50(%rsi), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x775b
movq %rax, %r13
movq (%r14), %rax
cmpq $0x2, 0x40(%rax)
movq %r13, %r12
jne 0x9113
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x775b
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8e9c
movq %rax, %r13
movl %ebp, (%rsp)
movl 0x4(%rsp), %ebp
jmp 0x914f
movq %rbx, %rdi
callq 0x775b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8e9c
movq %rax, %r12
movl $0x36, (%rsp)
movl $0x19, %ebp
movq %rax, %r13
movq 0x8(%r14), %rdi
callq 0xa81f
movq %rax, %r15
movq 0x10(%r14), %rdi
callq 0xa81f
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
movq %rbx, %rdi
movl (%rsp), %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x8dc2
movq %rbx, %rdi
movl $0x34, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8dc2
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: loc
static Loc *
loc(Isel *s, Node *n)
{
	Node *v;
	Ucon *uc;
	Loc *l;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xb, 0x8(%rsi)
je 0x91db
movq %rbx, %rdi
callq 0x1d422
cmpl $0x36, %eax
je 0x9217
cmpl $0x35, %eax
je 0x91ed
cmpl $0x33, %eax
jne 0x9261
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa5e9
movq 0x50(%rbx), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
cmpq $0x7, %rcx
ja 0x9284
leaq 0x27704(%rip), %rdx     # 0x3090c
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl 0x30(%rax), %r14d
jmp 0x9232
movq %rbx, %rdi
callq 0x1e384
movq 0x50(%rbx), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x22f1e
movq 0x8(%rax), %r14
movq %rbx, %rdi
callq 0x8efd
movq %r14, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaaa5
movq 0x30(%rax), %r14
jmp 0x9232
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq 0x30(%rax), %r14
jmp 0x9232
movq %rbx, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x5712e(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rsi
leaq 0x27a1e(%rip), %rdi     # 0x30c9b
xorl %eax, %eax
callq 0x13844
leaq 0x57a85(%rip), %rax     # 0x60d10
movq (%rax,%rcx,8), %rsi
leaq 0x279e6(%rip), %rdi     # 0x30c7c
jmp 0x927d
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: blit
static void
blit(Isel *s, Loc *to, Loc *from, size_t dstoff, size_t srcoff, size_t sz, size_t align)
{
	size_t i, modesz;
	Loc *sp, *dp; /* pointers to src, dst */
	Loc *tmp, *src, *dst; /* source memory, dst memory */

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

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

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl $0xe9, %eax
btq %r9, %rax
jb 0x9403
movq %r8, %rbx
testq %r8, %r8
je 0x93f4
movq %r9, %r14
movq %rcx, %r15
movq (%rsp), %rax
cmpl $0x2, (%rax)
jne 0x92e5
movq 0x8(%rsp), %r12
jmp 0x92fa
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x8e9c
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
cmpl $0x2, (%rsi)
je 0x9311
movq %r12, %rdi
callq 0x8e9c
movq %rax, 0x10(%rsp)
testq %r14, %r14
movl $0x8, %r12d
cmovneq %r14, %r12
movl $0xe9, %eax
btq %r12, %rax
jb 0x93f4
xorl %ebp, %ebp
movq %r15, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x27640(%rip), %rax     # 0x30980
movl (%rax,%r12,4), %r14d
movl %r14d, %edi
callq 0xa8da
leaq (%r12,%rbp), %rcx
cmpq %rbx, %rcx
ja 0x93e2
movq %rax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %rbp, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xa973
movq %rax, %r13
leaq (%r15,%rbp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xa973
movq %rax, %rbx
movq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
movq %r13, %rdx
movq 0x30(%rsp), %r12
movq 0x28(%rsp), %r13
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
movq %r15, %rdi
movl $0x1, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq 0x20(%rsp), %r15
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
addq %r12, %rbp
leaq (%r12,%rbp), %rax
cmpq %rbx, %rax
jbe 0x9363
shrq %r12
movl $0xe9, %eax
btq %r12, %rax
jae 0x9339
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x278ab(%rip), %rdi     # 0x30cb5
leaq 0x27665(%rip), %rsi     # 0x30a76
leaq 0x278b8(%rip), %rcx     # 0x30cd0
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: clear
static void
clear(Isel *s, Loc *val, size_t sz, size_t align)
{
	Loc *dp, *zero, *dst; /* source memory, dst memory */
	size_t modesz, i;

	i = 0;
	dp = inr(s, val);
	if (align == 0)
		align = 8;
	for (modesz = align; szmodes[modesz] != ModeNone; modesz /= 2) {
		zero = locreg(szmodes[modesz]);
		g(s, Ixor, zero, zero, NULL);
		while (i + modesz <= sz) {
			dst = locmem(i, dp, NULL, szmodes[modesz]);
			g(s, Imov, zero, dst, NULL);
			i += modesz;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x2, (%rsi)
jne 0x9441
movq %rsi, (%rsp)
jmp 0x944d
movq %r14, %rdi
callq 0x8e9c
movq %rax, (%rsp)
movl $0x8, %r15d
xorl %r12d, %r12d
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x27519(%rip), %rax     # 0x30980
movl (%rax,%r15,4), %r13d
movl %r13d, %edi
callq 0xa8da
movq %rax, %rbp
movq %r14, %rdi
movl $0x13, %esi
movq %rax, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
leaq (%r12,%r15), %rax
cmpq %rbx, %rax
jbe 0x949e
movq 0x8(%rsp), %r14
jmp 0x94dd
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r13d, %ecx
callq 0xa973
movq %r14, %rdi
movl $0x1, %esi
movq %rbp, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
addq %r15, %r12
leaq (%r15,%r12), %rax
cmpq 0x10(%rsp), %rax
jbe 0x94a7
shrq %r15
movl $0xe9, %eax
btq %r15, %rax
movq 0x10(%rsp), %rbx
jae 0x9460
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: movearg
static void
movearg(Isel *s, Loc *dst, PassIn p, Mode m, size_t *nfloats, size_t *nints, size_t *argoff)
{
	Loc *a;
	assert(m != ModeNone);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %edi
callq 0xa8da
movq %rax, %rbx
movl (%r14), %eax
cmpl $0x1, %eax
je 0x9989
cmpl $0x4, %eax
jne 0x996f
cmpq $0x0, 0x28(%r14)
je 0x9989
movq %r15, %rdi
movl $0x5, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8dc2
jmp 0x9995
movq 0x10(%r14), %rdi
callq 0xa7e7
movq %rax, %rbx
movl $0x8, %edi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x4, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xa973
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: load
static void
load(Isel *s, Loc *a, Loc *b)
{
	Loc *l;

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

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

// Assembly:
pushq %rbx
callq 0x227ac
movq %rax, %rbx
movl (%rax), %eax
cmpl $0xf, %eax
je 0xa267
cmpl $0x10, %eax
jne 0xa26e
movl $0x6, %eax
jmp 0xa2a3
movl $0x5, %eax
jmp 0xa2a3
movq %rbx, %rdi
callq 0x22784
movl %eax, %ecx
movl $0x4, %eax
testl %ecx, %ecx
jne 0xa2a3
movq %rbx, %rdi
callq 0x12421
movq %rax, %rcx
leaq -0x1(%rax), %rdx
xorl %eax, %eax
cmpq $0x7, %rdx
ja 0xa2a3
leaq 0x26a89(%rip), %rax     # 0x30d28
movl -0x4(%rax,%rcx,4), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: tymodepart
static Mode tymodepart(Type *t, int is_float, size_t displacement)
{
	assert(isstacktype(t));
	size_t sz = tysize(t);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x22784
testl %eax, %eax
je 0xa2fb
movq %r15, %rdi
callq 0x12421
movq %rax, %rcx
subq %r14, %rcx
testl %ebx, %ebx
je 0xa2db
xorl %eax, %eax
cmpq $0x4, %rcx
setne %al
addl $0x5, %eax
jmp 0xa2f5
leaq -0x1(%rcx), %rdx
movl $0x4, %eax
cmpq $0x3, %rdx
ja 0xa2f5
leaq 0x26a57(%rip), %rax     # 0x30d48
movl -0x4(%rax,%rcx,4), %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x26866(%rip), %rdi     # 0x30b68
leaq 0x2676d(%rip), %rsi     # 0x30a76
leaq 0x26867(%rip), %rcx     # 0x30b77
movl $0x5c, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/isel.c
// Function: varloc
static Loc *
varloc(Isel *s, Node *n)
{
	ssize_t off;
	Loc *l, *rip;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rdi
callq 0x2da24
testl %eax, %eax
je 0xa639
movl $0x65, %edi
callq 0xa93c
movq %rax, %r15
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x8efd
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xa9f9
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2da24
testl %eax, %eax
je 0xa66c
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
movq %rax, %r15
movq 0x68(%r14), %r14
movq %rbx, %rdi
callq 0x8efd
movq %r15, %rdi
movq %r14, %rsi
jmp 0xa6a9
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2da24
testl %eax, %eax
je 0xa6b7
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
movq %rax, %r14
negq %r14
movl $0x3c, %edi
callq 0xa93c
movq %rax, %r15
movq %rbx, %rdi
callq 0x8efd
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xa973
movq %rbx, %rdi
callq 0xec54
testl %eax, %eax
jne 0xa701
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
movq %rax, %r15
testq %rax, %rax
jne 0xa6f8
movq %rbx, %rdi
callq 0x8efd
movl %eax, %edi
callq 0xa8da
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d71e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x278a9(%rip), %rdi     # 0x31fb1
leaq 0x26367(%rip), %rsi     # 0x30a76
leaq 0x2654a(%rip), %rcx     # 0x30c60
movl $0xa2, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/locs.c
// Function: locstrlbl
Loc *
locstrlbl(char *lbl)
{
	Loc *l;

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x8, 0x8(%rdi)
jne 0xa871
movq 0x50(%rdi), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0xa890
cmpl $0x6, 0x18(%rax)
jne 0xa8af
movq 0x30(%rax), %rbx
movl $0x38, %edi
callq 0x2ce48
movq %rax, %r14
movabsq $0x400000001, %rax      # imm = 0x400000001
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x264e0(%rip), %rdi     # 0x30d58
leaq 0x264ea(%rip), %rsi     # 0x30d69
leaq 0x264ea(%rip), %rcx     # 0x30d70
movl $0x44, %edx
callq 0x4180
leaq 0x264ed(%rip), %rdi     # 0x30d84
leaq 0x264cb(%rip), %rsi     # 0x30d69
leaq 0x264cb(%rip), %rcx     # 0x30d70
movl $0x46, %edx
callq 0x4180
leaq 0x264e0(%rip), %rdi     # 0x30d96
leaq 0x264ac(%rip), %rsi     # 0x30d69
leaq 0x264ac(%rip), %rcx     # 0x30d70
movl $0x47, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/locs.c
// Function: locmem
Loc *
locmem(long disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

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

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

	l = locmem(disp, base, idx, mode);
	l->mem.scale = scale;
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x38, %edi
callq 0x2ce48
movl $0x3, (%rax)
movl %ebx, 0x4(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movl %ebp, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/locs.c
// Function: loclit
Loc *
loclit(long val, Mode m)
{
	Loc *l;

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

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

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x268fd(%rip), %rdi     # 0x31aee
xorl %eax, %eax
callq 0x4140
leaq 0x269e0(%rip), %rdi     # 0x31bdf
callq 0x40b0
leaq 0x269eb(%rip), %rdi     # 0x31bf6
callq 0x40b0
leaq 0x269f5(%rip), %rdi     # 0x31c0c
callq 0x40b0
leaq 0x269ff(%rip), %rdi     # 0x31c22
callq 0x40b0
leaq 0x26a26(%rip), %rdi     # 0x31c55
callq 0x40b0
leaq 0x26a33(%rip), %rdi     # 0x31c6e
callq 0x40b0
leaq 0x26a57(%rip), %rdi     # 0x31c9e
callq 0x40b0
leaq 0x26a72(%rip), %rdi     # 0x31cc5
callq 0x40b0
leaq 0x26a99(%rip), %rdi     # 0x31cf8
callq 0x40b0
leaq 0x26aac(%rip), %rdi     # 0x31d17
callq 0x40b0
leaq 0x26ac2(%rip), %rdi     # 0x31d39
callq 0x40b0
leaq 0x26af4(%rip), %rdi     # 0x31d77
callq 0x40b0
leaq 0x26afe(%rip), %rdi     # 0x31d8d
callq 0x40b0
leaq 0x26b11(%rip), %rdi     # 0x31dac
callq 0x40b0
leaq 0x26b1f(%rip), %rdi     # 0x31dc6
callq 0x40b0
leaq 0x26b39(%rip), %rdi     # 0x31dec
callq 0x40b0
leaq 0x26b55(%rip), %rdi     # 0x31e14
popq %rax
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/main.c
// Function: dirname
static char *
dirname(char *path)
{
	char *p;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x55eba(%rip), %r14     # 0x611c0
movq %r14, %rdi
movl $0x2e, %esi
callq 0x4160
testq %rax, %rax
je 0xb333
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x2e125
leaq 0x26809(%rip), %rdx     # 0x31b43
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2dfae
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/main.c
// Function: mkpath
static void
mkpath(char *p)
{
	char *e, path[256];

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
callq 0x4120
cmpq $0xff, %rax
ja 0xb3d7
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x4130
testq %rax, %rax
je 0xb3c8
movq %rax, %r14
movq %rsp, %r15
movq %r14, %r12
subq %rbx, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4270
movb $0x0, (%rsp,%r12)
movq %r15, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x40a0
incq %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x4130
movq %rax, %r14
testq %rax, %rax
jne 0xb38a
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x26786(%rip), %rdi     # 0x31b64
leaq 0x26798(%rip), %rsi     # 0x31b7d
leaq 0x26798(%rip), %rcx     # 0x31b84
movl $0x4b, %edx
callq 0x4180
nop
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/ra.c
// Function: issubreg
int
issubreg(Loc *a, Loc *b)
{
	if(a->type != Locreg || b->type != Locreg)
		return 0;
	if(a->reg.colour == Rnone || b->reg.colour == Rnone)
		return 0;
	return rclass(a) == rclass(b) && a->mode != b->mode;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, (%rdi)
jne 0xb46a
cmpl $0x2, (%rsi)
jne 0xb46a
cmpl $0x0, 0x18(%rdi)
je 0xb46a
cmpl $0x0, 0x18(%rsi)
je 0xb46a
movl 0x4(%rdi), %ecx
leal -0x1(%rcx), %r8d
xorl %edx, %edx
leaq 0x26c93(%rip), %rax     # 0x320cc
movl $0x0, %edi
cmpl $0x5, %r8d
ja 0xb44a
movl %r8d, %edi
movl (%rax,%rdi,4), %edi
movl 0x4(%rsi), %esi
leal -0x1(%rsi), %r8d
cmpl $0x5, %r8d
ja 0xb45d
movl %r8d, %edx
movl (%rax,%rdx,4), %edx
xorl %eax, %eax
cmpl %edx, %edi
jne 0xb46a
xorl %eax, %eax
cmpl %esi, %ecx
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0xb583
cmpq $0x0, 0x30(%rcx)
je 0xb583
pushq %rbx
leaq 0x10(%rcx), %rax
xorl %edx, %edx
leaq 0x559d1(%rip), %rsi     # 0x60e80
movq (%rax,%rdx,8), %r8
movl (%r8), %r9d
leal -0x3(%r9), %r10d
cmpl $0x2, %r10d
jae 0xb535
movq 0x28(%r8), %r9
testq %r9, %r9
je 0xb4fd
movq 0x10(%r9), %r9
movq 0x3d0(%rdi), %r10
cmpq %r10, %r9
jae 0xb4f2
movq 0x3e8(%rdi), %r11
movq (%r11,%r9,8), %rbx
testq %rbx, %rbx
je 0xb4f2
movq 0x10(%rbx), %r9
cmpq %r10, %r9
jb 0xb4e0
movq (%rsi), %r10
movq (%r10,%r9,8), %r9
movq %r9, 0x28(%r8)
movq 0x30(%r8), %r9
testq %r9, %r9
je 0xb575
movq 0x10(%r9), %r9
movq 0x3d0(%rdi), %r10
cmpq %r10, %r9
jae 0xb52f
movq 0x3e8(%rdi), %r11
movq (%r11,%r9,8), %rbx
testq %rbx, %rbx
je 0xb52f
movq 0x10(%rbx), %r9
cmpq %r10, %r9
jb 0xb51d
addq $0x30, %r8
jmp 0xb568
cmpl $0x2, %r9d
jne 0xb575
movq 0x10(%r8), %r9
movq 0x3d0(%rdi), %r8
cmpq %r8, %r9
jae 0xb564
movq 0x3e8(%rdi), %r10
movq (%r10,%r9,8), %r11
testq %r11, %r11
je 0xb564
movq 0x10(%r11), %r9
cmpq %r8, %r9
jb 0xb552
leaq (%rax,%rdx,8), %r8
movq (%rsi), %r10
leaq (%r10,%r9,8), %r9
movq (%r9), %r9
movq %r9, (%r8)
incq %rdx
cmpq 0x30(%rcx), %rdx
jb 0xb4af
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x0, 0x3d0(%rdi)
je 0xd8d2
xorl %r14d, %r14d
movq 0x3b8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4040
incq %r14
cmpq 0x3d0(%rbx), %r14
jb 0xd8b6
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_O3/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 0x24514(%rip), %rsi     # 0x31e2f
xorl %eax, %eax
callq 0x4240
testq %r14, %r14
je 0xd977
leaq 0x2451c(%rip), %rdi     # 0x31e4a
leaq 0x24501(%rip), %r12     # 0x31e36
leaq 0x2b40c(%rip), %r13     # 0x38d48
xorl %ebp, %ebp
movq %rbx, %rsi
callq 0x4190
movq (%r15,%rbp,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x6752
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
cmpq %rbp, %r14
jne 0xd93e
leaq 0x2525f(%rip), %rdi     # 0x32bdd
movl $0x2, %esi
movl $0x1, %edx
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x246f5(%rip), %rsi     # 0x320ae
xorl %eax, %eax
callq 0x4240
leaq 0x534b9(%rip), %r12     # 0x60e80
movq (%r12), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x6752
leaq 0x246d0(%rip), %rdi     # 0x320b3
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
movq (%r12), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x6752
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %rdi
callq 0x2d361
testq %rax, %rax
je 0xda9f
leaq 0x24403(%rip), %r12     # 0x31e4a
leaq 0x2466a(%rip), %r15     # 0x320b8
leaq 0x2b2f3(%rip), %rbp     # 0x38d48
xorl %r13d, %r13d
movq (%r14), %rax
shlq $0x6, %rax
cmpq %r13, %rax
jbe 0xda8f
movq 0x8(%r14), %rax
movq %r13, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r13, %rax
jae 0xda8f
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4240
movq %rbp, %r12
incq %r13
movq %r14, %rdi
callq 0x2d361
cmpq %rax, %r13
jb 0xda58
movl $0xa, %edi
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_O3/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
movq %rsi, %rdi
callq 0x2d361
testq %rax, %rax
je 0xdb44
leaq 0x2436b(%rip), %r15     # 0x31e4a
xorl %r12d, %r12d
leaq 0x53397(%rip), %r13     # 0x60e80
leaq 0x2b258(%rip), %rbp     # 0x38d48
movq (%r14), %rax
shlq $0x6, %rax
cmpq %r12, %rax
jbe 0xdb34
movq 0x8(%r14), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jae 0xdb34
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4190
movq (%r13), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x6752
movq %rbp, %r15
incq %r12
movq %r14, %rdi
callq 0x2d361
cmpq %rax, %r12
jb 0xdaf0
movl $0xa, %edi
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
leaq 0x36d2f(%rip), %r12     # 0x448b0
addq %r12, %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
movslq (%rax,%rcx,4), %rdx
testq %rdx, %rdx
je 0xdbbb
movq 0x8(%r14,%rdx,8), %rdx
cmpl $0x2, (%rdx)
jne 0xdbb2
movl 0x18(%rdx), %esi
addl $-0x2d, %esi
cmpl $-0x3, %esi
ja 0xdbb2
movq 0x10(%rdx), %rdx
movq %rdx, (%rbx,%r15,8)
incq %r15
incq %rcx
cmpq $0x4, %rcx
jne 0xdb89
leaq (%rbx,%r15,8), %rbp
xorl %r13d, %r13d
movl 0x8(%r14), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
addq %r12, %rax
movl 0x19c(%rax,%r13,4), %edi
testl %edi, %edi
je 0xdbf3
callq 0xa93c
movq 0x10(%rax), %rax
movq %rax, (%rbp,%r13,8)
incq %r13
cmpq $0x66, %r13
jne 0xdbc2
addq %r13, %r15
cmpq $0x0, 0x30(%r14)
je 0xdc59
xorl %eax, %eax
movq 0x10(%r14,%rax,8), %rcx
movl (%rcx), %edx
addl $-0x3, %edx
cmpl $0x1, %edx
ja 0xdc50
movq 0x28(%rcx), %rdx
testq %rdx, %rdx
je 0xdc2d
movl 0x18(%rdx), %esi
addl $-0x2d, %esi
cmpl $-0x3, %esi
ja 0xdc2d
movq 0x10(%rdx), %rdx
movq %rdx, (%rbx,%r15,8)
incq %r15
movq 0x30(%rcx), %rdx
testq %rdx, %rdx
je 0xdc50
movq 0x28(%rcx), %rcx
movl 0x18(%rcx), %ecx
addl $-0x2d, %ecx
cmpl $-0x3, %ecx
ja 0xdc50
movq 0x10(%rdx), %rcx
movq %rcx, (%rbx,%r15,8)
incq %r15
incq %rax
cmpq 0x30(%r14), %rax
jb 0xdbff
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %r14
movl 0x8(%rdi), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
leaq 0x44708(%rip), %r15     # 0x52390
addq %r15, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
movslq (%rax,%rcx,4), %rdx
testq %rdx, %rdx
je 0xdcc1
movq 0x8(%r14,%rdx,8), %rdx
cmpl $0x2, (%rdx)
jne 0xdcb8
movl 0x18(%rdx), %edi
addl $-0x2d, %edi
cmpl $-0x3, %edi
ja 0xdcb8
movq 0x10(%rdx), %rdx
movq %rdx, (%rsi,%rbx,8)
incq %rbx
incq %rcx
cmpq $0x4, %rcx
jne 0xdc8f
leaq (%rsi,%rbx,8), %r13
xorl %r12d, %r12d
movl 0x8(%r14), %eax
imulq $0x338, %rax, %rax      # imm = 0x338
addq %r15, %rax
movl 0x19c(%rax,%r12,4), %edi
testl %edi, %edi
je 0xdcf9
callq 0xa93c
movq 0x10(%rax), %rax
movq %rax, (%r13,%r12,8)
incq %r12
cmpq $0x66, %r12
jne 0xdcc8
addq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdd61
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x3b0(%rdi), %rax
movq 0x3d0(%rdi), %rcx
imulq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rax
btq %rcx, %rax
jb 0xdd5c
leaq -0x3b(%r15), %rcx
movabsq $0x40000000003, %rax    # imm = 0x40000000003
cmpq $0x2a, %rcx
ja 0xdd62
btq %rcx, %rax
jae 0xdd62
popq %rbx
popq %r14
popq %r15
retq
leaq -0x3b(%rbx), %rcx
cmpq $0x2a, %rcx
ja 0xdd72
btq %rcx, %rax
jb 0xdd5c
leaq 0x53107(%rip), %rax     # 0x60e80
movq (%rax), %rsi
movq (%rsi,%r15,8), %rax
movl 0x4(%rax), %edi
decl %edi
xorl %eax, %eax
leaq 0x2433e(%rip), %rcx     # 0x320cc
movl $0x0, %edx
cmpl $0x5, %edi
ja 0xdd9d
movl %edi, %edx
movl (%rcx,%rdx,4), %edx
movq (%rsi,%rbx,8), %rsi
movl 0x4(%rsi), %esi
decl %esi
cmpl $0x5, %esi
ja 0xddb0
movl %esi, %eax
movl (%rcx,%rax,4), %eax
cmpl %eax, %edx
jne 0xdd5c
movq 0x4c0(%r14), %rax
movq (%rax), %rsi
shlq $0x6, %rsi
cmpq %r15, %rsi
jbe 0xddfd
movl $0x1, %edx
movl %r15d, %ecx
shlq %cl, %rdx
cmpq %rbx, %rsi
jbe 0xddfd
movq 0x8(%rax), %rax
movq %r15, %rcx
shrq $0x6, %rcx
andq (%rax,%rcx,8), %rdx
je 0xddfd
movq %rbx, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rbx, %rax
jb 0xdd5c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xdebf
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xdebf
movq 0x4c0(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %r15, %rcx
jbe 0xde41
movq 0x8(%rax), %rdx
movq %r15, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rdx
btq %r15, %rdx
jb 0xde76
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xdf5d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xdfd9
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%r15,4)
movq 0x4c0(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %rbx, %rcx
jbe 0xde94
movq 0x8(%rax), %rax
movq %rbx, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rbx, %rax
jb 0xdd5c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xdf5d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xdfd9
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%rbx,4)
jmp 0xdd5c
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x3b0(%rdi), %r8
movq 0x3d0(%rdi), %rax
movq %rax, %rcx
imulq %rsi, %rcx
addq %rdx, %rcx
imulq %rdx, %rax
addq %rsi, %rax
movl $0x1, %r9d
movl $0x1, %r10d
shlq %cl, %r10
shrq $0x6, %rcx
orq %r10, (%r8,%rcx,8)
movl %eax, %ecx
shlq %cl, %r9
shrq $0x6, %rax
orq %r9, (%r8,%rax,8)
movq 0x3d0(%rdi), %rax
movq %rax, %rcx
imulq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rdi
shrq $0x6, %rdi
movq (%r8,%rdi,8), %rdi
btq %rcx, %rdi
jae 0xdf3d
imulq %rsi, %rax
addq %rdx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq (%r8,%rcx,8), %rcx
btq %rax, %rcx
jae 0xdf3d
retq
pushq %rax
leaq 0x23fc4(%rip), %rdi     # 0x31f09
leaq 0x23f78(%rip), %rsi     # 0x31ec4
leaq 0x23fdf(%rip), %rcx     # 0x31f32
movl $0x16c, %edx            # imm = 0x16C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x4c0(%rdi), %rcx
movq (%rcx), %r8
shlq $0x6, %r8
cmpq %rsi, %r8
jbe 0xe009
movq 0x8(%rcx), %rax
movq %rsi, %r9
shrq $0x6, %r9
movq (%rax,%r9,8), %rax
btq %rsi, %rax
jae 0xe009
movq %rsi, %rcx
movq %rdx, %rsi
jmp 0xe02b
movl $0x1, %eax
cmpq %rdx, %r8
jbe 0xe088
movq 0x8(%rcx), %rcx
movq %rdx, %r8
shrq $0x6, %r8
movq (%rcx,%r8,8), %rcx
btq %rdx, %rcx
movq %rdx, %rcx
jae 0xe088
leaq 0x5218e(%rip), %rax     # 0x601c0
movslq (%rax,%rcx,4), %rdx
leaq (%rdx,%rdx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rdx, %rax
xorl %edx, %edx
leaq 0x51e26(%rip), %r8      # 0x5fe70
leaq (%rax,%rdx,4), %r9
movl (%r8,%r9), %r9d
cmpq %r9, %rcx
je 0xe07a
movq 0x3b0(%rdi), %r10
imulq 0x3d0(%rdi), %r9
addq %rsi, %r9
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe089
incq %rdx
cmpq $0x7, %rdx
jne 0xe04a
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x408(%rdi), %rax
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xe145
movq 0x400(%rdi), %rdx
movq 0x440(%rdi), %rcx
movq (%rdx,%rsi,8), %rdx
movq (%rcx), %rsi
shlq $0x6, %rsi
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
movq (%r9), %r9
cmpq %r9, %rsi
jbe 0xe115
movq 0x8(%rcx), %r10
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe148
movq 0x458(%rdi), %r10
movq (%r10), %r11
shlq $0x6, %r11
cmpq %r9, %r11
jbe 0xe13d
movq 0x8(%r10), %r10
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe148
incq %r8
cmpq %r8, %rax
jne 0xe0f4
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x52d2b(%rip), %rax     # 0x60e80
movq (%rax), %rax
movq (%rax,%rsi,8), %rcx
leaq 0x4a0(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, 0x8(%rcx)
je 0xe193
movq 0x4b0(%rdi), %rcx
movq (%rcx), %rdx
shlq $0x6, %rdx
cmpq %rsi, %rdx
jbe 0xe194
movq 0x8(%rcx), %rcx
movq %rsi, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rsi, %rcx
jae 0xe194
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe4ac
movq (%r14), %r15
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xe496
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 %r14d, %r14d
movq 0x440(%rbx), %rcx
movq (%r15,%r14,8), %rax
movq (%rax), %rax
movq (%rcx), %rdx
shlq $0x6, %rdx
cmpq %rax, %rdx
jbe 0xe488
movq 0x8(%rcx), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jae 0xe488
movq (%r12), %rax
testq %rax, %rax
je 0xe488
xorl %ebp, %ebp
movq (%r15,%r14,8), %rcx
movq (%r13), %rdx
cmpq (%rdx,%rbp,8), %rcx
jne 0xe480
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x2cfcc
movq (%r15,%r14,8), %rdx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ceff
movq 0x440(%rbx), %rdi
movq (%r15,%r14,8), %rax
movq (%rax), %rsi
callq 0x2d3d4
movq 0x458(%rbx), %rdi
movq (%r15,%r14,8), %rax
movq (%rax), %rsi
callq 0x2d369
movq 0x450(%rbx), %rax
incq %rbp
cmpq %rax, %rbp
jb 0xe424
incq %r14
cmpq 0x8(%rsp), %r14
jne 0xe3e6
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x408(%rdi), %rax
movq (%rax,%rsi,8), %r12
leaq (,%r12,8), %rdi
callq 0x4280
testq %r12, %r12
je 0xe552
movq 0x400(%r14), %rcx
movq 0x440(%r14), %rdx
movq (%rdx), %rsi
shlq $0x6, %rsi
movq (%rcx,%r15,8), %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
movq (%rdi,%r8,8), %r9
movq (%r9), %r10
cmpq %r10, %rsi
jbe 0xe519
movq 0x8(%rdx), %r11
movq %r10, %r15
shrq $0x6, %r15
movq (%r11,%r15,8), %r11
btq %r10, %r11
jb 0xe541
movq 0x458(%r14), %r11
movq (%r11), %r15
shlq $0x6, %r15
cmpq %r10, %r15
jbe 0xe548
movq 0x8(%r11), %r11
movq %r10, %r15
shrq $0x6, %r15
movq (%r11,%r15,8), %r11
btq %r10, %r11
jae 0xe548
movq %r9, (%rax,%rcx,8)
incq %rcx
incq %r8
cmpq %r8, %r12
jne 0xe4f8
jmp 0xe554
xorl %ecx, %ecx
movq %rax, (%rbx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq