LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x2decd
testl %eax, %eax
je 0xa76e
movl $0x65, %edi
callq 0xaa70
movq %rax, %r15
movq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x8feb
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xab2d
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2decd
testl %eax, %eax
je 0xa7a1
movq 0x58(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
movq %rax, %r15
movq 0x68(%r14), %r14
movq %rbx, %rdi
callq 0x8feb
movq %r15, %rdi
movq %r14, %rsi
jmp 0xa7de
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2decd
testl %eax, %eax
je 0xa7ec
movq 0x50(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
movq %rax, %r14
negq %r14
movl $0x3c, %edi
callq 0xaa70
movq %rax, %r15
movq %rbx, %rdi
callq 0x8feb
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xaaa7
movq %rbx, %rdi
callq 0xee80
testl %eax, %eax
jne 0xa836
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
movq %rax, %r15
testq %rax, %rax
jne 0xa82d
movq %rbx, %rdi
callq 0x8feb
movl %eax, %edi
callq 0xaa0e
movq %rax, %r15
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2dbc2
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x27764(%rip), %rdi     # 0x31fa1
leaq 0x26222(%rip), %rsi     # 0x30a66
leaq 0x26405(%rip), %rcx     # 0x30c50
movl $0xa2, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
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_O1/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 0x2d348
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_O1/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 0xa9a5
movq 0x50(%rdi), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0xa9c4
cmpl $0x6, 0x18(%rax)
jne 0xa9e3
movq 0x30(%rax), %rbx
movl $0x38, %edi
callq 0x2d348
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 0x2639c(%rip), %rdi     # 0x30d48
leaq 0x263a6(%rip), %rsi     # 0x30d59
leaq 0x263a6(%rip), %rcx     # 0x30d60
movl $0x44, %edx
callq 0x4180
leaq 0x263a9(%rip), %rdi     # 0x30d74
leaq 0x26387(%rip), %rsi     # 0x30d59
leaq 0x26387(%rip), %rcx     # 0x30d60
movl $0x46, %edx
callq 0x4180
leaq 0x2639c(%rip), %rdi     # 0x30d86
leaq 0x26368(%rip), %rsi     # 0x30d59
leaq 0x26368(%rip), %rcx     # 0x30d60
movl $0x47, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
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_O1/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 0x2d348
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_O1/oridb[P]mc/6/locs.c
// Function: locmeml
Loc *
locmeml(char *disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x38, %edi
callq 0x2d348
movq %rax, %r13
movl $0x4, (%rax)
movl %ebx, 0x4(%rax)
movq %r12, %rdi
callq 0x4340
movq %rax, 0x10(%r13)
movq %r15, 0x28(%r13)
movq %r14, 0x30(%r13)
movl $0x1, 0x20(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/locs.c
// Function: locmemls
Loc *
locmemls(char *disp, Loc *base, Loc *idx, int scale, Mode mode)
{
	Loc *l;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x38, %edi
callq 0x2d348
movq %rax, %r13
movl $0x4, (%rax)
movl %ebx, 0x4(%rax)
movq %r12, %rdi
callq 0x4340
movq %rax, 0x10(%r13)
movq %r15, 0x28(%r13)
movq %r14, 0x30(%r13)
movl %ebp, 0x20(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
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_O1/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 0x267a7(%rip), %rdi     # 0x31ade
xorl %eax, %eax
callq 0x4140
leaq 0x2688a(%rip), %rdi     # 0x31bcf
callq 0x40b0
leaq 0x26895(%rip), %rdi     # 0x31be6
callq 0x40b0
leaq 0x2689f(%rip), %rdi     # 0x31bfc
callq 0x40b0
leaq 0x268a9(%rip), %rdi     # 0x31c12
callq 0x40b0
leaq 0x268d0(%rip), %rdi     # 0x31c45
callq 0x40b0
leaq 0x268dd(%rip), %rdi     # 0x31c5e
callq 0x40b0
leaq 0x26901(%rip), %rdi     # 0x31c8e
callq 0x40b0
leaq 0x2691c(%rip), %rdi     # 0x31cb5
callq 0x40b0
leaq 0x26943(%rip), %rdi     # 0x31ce8
callq 0x40b0
leaq 0x26956(%rip), %rdi     # 0x31d07
callq 0x40b0
leaq 0x2696c(%rip), %rdi     # 0x31d29
callq 0x40b0
leaq 0x2699e(%rip), %rdi     # 0x31d67
callq 0x40b0
leaq 0x269a8(%rip), %rdi     # 0x31d7d
callq 0x40b0
leaq 0x269bb(%rip), %rdi     # 0x31d9c
callq 0x40b0
leaq 0x269c9(%rip), %rdi     # 0x31db6
callq 0x40b0
leaq 0x269e3(%rip), %rdi     # 0x31ddc
callq 0x40b0
leaq 0x269ff(%rip), %rdi     # 0x31e04
popq %rax
jmp 0x40b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb42d
subq %rbx, %rax
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x2e4ec
leaq 0x2ca87(%rip), %rdi     # 0x37ebb
popq %rbx
jmp 0x2e51f
// File: /workspace/github_c_makefile_star2_O1/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 0x55d74(%rip), %r14     # 0x611c0
movq %r14, %rdi
movl $0x2e, %esi
callq 0x4160
testq %rax, %rax
je 0xb479
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x2e5a5
leaq 0x266b3(%rip), %rdx     # 0x31b33
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e42e
// File: /workspace/github_c_makefile_star2_O1/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 0xb51d
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x4130
testq %rax, %rax
je 0xb50e
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 0xb4d0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x26630(%rip), %rdi     # 0x31b54
leaq 0x26642(%rip), %rsi     # 0x31b6d
leaq 0x26642(%rip), %rcx     # 0x31b74
movl $0x4b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0xb5ae
cmpl $0x2, (%rsi)
jne 0xb5ae
cmpl $0x0, 0x18(%rdi)
je 0xb5ae
cmpl $0x0, 0x18(%rsi)
je 0xb5ae
movl 0x4(%rdi), %ecx
leal -0x1(%rcx), %r8d
xorl %edx, %edx
leaq 0x26b3f(%rip), %rax     # 0x320bc
movl $0x0, %edi
cmpl $0x5, %r8d
ja 0xb58e
movl %r8d, %edi
movl (%rax,%rdi,4), %edi
movl 0x4(%rsi), %esi
leal -0x1(%rsi), %r8d
cmpl $0x5, %r8d
ja 0xb5a1
movl %r8d, %edx
movl (%rax,%rdx,4), %edx
xorl %eax, %eax
cmpl %edx, %edi
jne 0xb5ae
xorl %eax, %eax
cmpl %esi, %ecx
setne %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb6c7
cmpq $0x0, 0x30(%rcx)
je 0xb6c7
pushq %rbx
leaq 0x10(%rcx), %rax
xorl %edx, %edx
leaq 0x5588d(%rip), %rsi     # 0x60e80
movq (%rax,%rdx,8), %r8
movl (%r8), %r9d
leal -0x3(%r9), %r10d
cmpl $0x2, %r10d
jae 0xb679
movq 0x28(%r8), %r9
testq %r9, %r9
je 0xb641
movq 0x10(%r9), %r9
movq 0x3d0(%rdi), %r10
cmpq %r9, %r10
jbe 0xb636
movq 0x3e8(%rdi), %r11
movq (%r11,%r9,8), %rbx
testq %rbx, %rbx
je 0xb636
movq 0x10(%rbx), %r9
cmpq %r10, %r9
jb 0xb624
movq (%rsi), %r10
movq (%r10,%r9,8), %r9
movq %r9, 0x28(%r8)
movq 0x30(%r8), %r9
testq %r9, %r9
je 0xb6b9
movq 0x10(%r9), %r9
movq 0x3d0(%rdi), %r10
cmpq %r9, %r10
jbe 0xb673
movq 0x3e8(%rdi), %r11
movq (%r11,%r9,8), %rbx
testq %rbx, %rbx
je 0xb673
movq 0x10(%rbx), %r9
cmpq %r10, %r9
jb 0xb661
addq $0x30, %r8
jmp 0xb6ac
cmpl $0x2, %r9d
jne 0xb6b9
movq 0x10(%r8), %r9
movq 0x3d0(%rdi), %r8
cmpq %r9, %r8
jbe 0xb6a8
movq 0x3e8(%rdi), %r10
movq (%r10,%r9,8), %r11
testq %r11, %r11
je 0xb6a8
movq 0x10(%r11), %r9
cmpq %r8, %r9
jb 0xb696
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 0xb5f3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda8c
xorl %r14d, %r14d
movq 0x3b8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4040
incq %r14
cmpq 0x3d0(%rbx), %r14
jb 0xda70
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_O1/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 0x2434a(%rip), %rsi     # 0x31e1f
xorl %eax, %eax
callq 0x4240
testq %r14, %r14
je 0xdb31
leaq 0x24352(%rip), %rdi     # 0x31e3a
leaq 0x24337(%rip), %r12     # 0x31e26
leaq 0x2b282(%rip), %r13     # 0x38d78
xorl %ebp, %ebp
movq %rbx, %rsi
callq 0x4190
movq (%r15,%rbp,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x680e
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 0xdaf8
leaq 0x25095(%rip), %rdi     # 0x32bcd
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_O1/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 0x2452b(%rip), %rsi     # 0x3209e
xorl %eax, %eax
callq 0x4240
leaq 0x532ff(%rip), %r12     # 0x60e80
movq (%r12), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x680e
leaq 0x24506(%rip), %rdi     # 0x320a3
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 0x680e
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_O1/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 0x2d80e
testq %rax, %rax
je 0xdc59
leaq 0x24239(%rip), %r12     # 0x31e3a
leaq 0x244a0(%rip), %r15     # 0x320a8
leaq 0x2b169(%rip), %rbp     # 0x38d78
xorl %r13d, %r13d
movq (%r14), %rax
shlq $0x6, %rax
cmpq %r13, %rax
jbe 0xdc49
movq 0x8(%r14), %rax
movq %r13, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r13, %rax
jae 0xdc49
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 0x2d80e
cmpq %rax, %r13
jb 0xdc12
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_O1/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 0x2d80e
testq %rax, %rax
je 0xdcfe
leaq 0x241a1(%rip), %r15     # 0x31e3a
xorl %r12d, %r12d
leaq 0x531dd(%rip), %r13     # 0x60e80
leaq 0x2b0ce(%rip), %rbp     # 0x38d78
movq (%r14), %rax
shlq $0x6, %rax
cmpq %r12, %rax
jbe 0xdcee
movq 0x8(%r14), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jae 0xdcee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4190
movq (%r13), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
movl $0x78, %edx
callq 0x680e
movq %rbp, %r15
incq %r12
movq %r14, %rdi
callq 0x2d80e
cmpq %rax, %r12
jb 0xdcaa
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_O1/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 0x36b75(%rip), %r12     # 0x448b0
addq %r12, %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
movslq (%rax,%rcx,4), %rdx
testq %rdx, %rdx
je 0xdd75
movq 0x8(%r14,%rdx,8), %rdx
cmpl $0x2, (%rdx)
jne 0xdd6c
movl 0x18(%rdx), %esi
addl $-0x2d, %esi
cmpl $-0x3, %esi
ja 0xdd6c
movq 0x10(%rdx), %rdx
movq %rdx, (%rbx,%r15,8)
incq %r15
incq %rcx
cmpq $0x4, %rcx
jne 0xdd43
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 0xddad
callq 0xaa70
movq 0x10(%rax), %rax
movq %rax, (%rbp,%r13,8)
incq %r13
cmpq $0x66, %r13
jne 0xdd7c
addq %r13, %r15
cmpq $0x0, 0x30(%r14)
je 0xde13
xorl %eax, %eax
movq 0x10(%r14,%rax,8), %rcx
movl (%rcx), %edx
addl $-0x3, %edx
cmpl $0x1, %edx
ja 0xde0a
movq 0x28(%rcx), %rdx
testq %rdx, %rdx
je 0xdde7
movl 0x18(%rdx), %esi
addl $-0x2d, %esi
cmpl $-0x3, %esi
ja 0xdde7
movq 0x10(%rdx), %rdx
movq %rdx, (%rbx,%r15,8)
incq %r15
movq 0x30(%rcx), %rdx
testq %rdx, %rdx
je 0xde0a
movq 0x28(%rcx), %rcx
movl 0x18(%rcx), %ecx
addl $-0x2d, %ecx
cmpl $-0x3, %ecx
ja 0xde0a
movq 0x10(%rdx), %rcx
movq %rcx, (%rbx,%r15,8)
incq %r15
incq %rax
cmpq 0x30(%r14), %rax
jb 0xddb9
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_O1/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 0x4454e(%rip), %r15     # 0x52390
addq %r15, %rax
xorl %ecx, %ecx
xorl %ebx, %ebx
movslq (%rax,%rcx,4), %rdx
testq %rdx, %rdx
je 0xde7b
movq 0x8(%r14,%rdx,8), %rdx
cmpl $0x2, (%rdx)
jne 0xde72
movl 0x18(%rdx), %edi
addl $-0x2d, %edi
cmpl $-0x3, %edi
ja 0xde72
movq 0x10(%rdx), %rdx
movq %rdx, (%rsi,%rbx,8)
incq %rbx
incq %rcx
cmpq $0x4, %rcx
jne 0xde49
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 0xdeb3
callq 0xaa70
movq 0x10(%rax), %rax
movq %rax, (%r13,%r12,8)
incq %r12
cmpq $0x66, %r12
jne 0xde82
addq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdf1b
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x3d0(%rdi), %rax
imulq %rdx, %rax
addq %rsi, %rax
movq 0x3b0(%rdi), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jb 0xdf16
leaq -0x3b(%r15), %rcx
movabsq $0x40000000003, %rax    # imm = 0x40000000003
cmpq $0x2a, %rcx
ja 0xdf1c
btq %rcx, %rax
jae 0xdf1c
popq %rbx
popq %r14
popq %r15
retq
leaq -0x3b(%rbx), %rcx
cmpq $0x2a, %rcx
ja 0xdf2c
btq %rcx, %rax
jb 0xdf16
leaq 0x52f4d(%rip), %rax     # 0x60e80
movq (%rax), %rsi
movq (%rsi,%r15,8), %rax
movl 0x4(%rax), %edi
decl %edi
xorl %eax, %eax
leaq 0x24174(%rip), %rcx     # 0x320bc
movl $0x0, %edx
cmpl $0x5, %edi
ja 0xdf57
movl %edi, %edx
movl (%rcx,%rdx,4), %edx
movq (%rsi,%rbx,8), %rsi
movl 0x4(%rsi), %esi
decl %esi
cmpl $0x5, %esi
ja 0xdf6a
movl %esi, %eax
movl (%rcx,%rax,4), %eax
cmpl %eax, %edx
jne 0xdf16
movq 0x4c0(%r14), %rax
movq (%rax), %rsi
shlq $0x6, %rsi
cmpq %r15, %rsi
jbe 0xdfbb
movl $0x1, %edx
movl %r15d, %ecx
shlq %cl, %rdx
cmpq %rbx, %rsi
jbe 0xdfbb
movq 0x8(%rax), %rcx
movq %r15, %rsi
shrq $0x6, %rsi
andq (%rcx,%rsi,8), %rdx
je 0xdfbb
movq 0x8(%rax), %rax
movq %rbx, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rbx, %rax
jb 0xdf16
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe07d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe07d
movq 0x4c0(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %r15, %rcx
jbe 0xdfff
movq 0x8(%rax), %rax
movq %r15, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r15, %rax
jb 0xe026
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe11b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe197
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%r15,4)
movq 0x4c0(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %rbx, %rcx
jbe 0xe052
movq 0x8(%rax), %rax
movq %rbx, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rbx, %rax
jb 0xdf16
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe11b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe197
movq 0x3d8(%r14), %rcx
addl %eax, (%rcx,%rbx,4)
jmp 0xdf16
// File: /workspace/github_c_makefile_star2_O1/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 0xe0fb
imulq %rsi, %rax
addq %rdx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq (%r8,%rcx,8), %rcx
btq %rax, %rcx
jae 0xe0fb
retq
pushq %rax
leaq 0x23df6(%rip), %rdi     # 0x31ef9
leaq 0x23daa(%rip), %rsi     # 0x31eb4
leaq 0x23e11(%rip), %rcx     # 0x31f22
movl $0x16c, %edx            # imm = 0x16C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/ra.c
// Function: alputedge
static void
alputedge(Isel *s, regid u, regid v)
{
	if (s->ngadj[u] == s->gadjsz[u]) {
		s->gadjsz[u] = s->gadjsz[u]*2 + 1;
		s->gadj[u] = xrealloc(s->gadj[u], s->gadjsz[u]*sizeof(regid));
	}
	s->gadj[u][s->ngadj[u]] = v;
	s->ngadj[u]++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3c0(%rdi), %rdx
movq 0x3c8(%rdi), %rcx
movq (%rcx,%rsi,8), %rax
cmpq %rax, (%rdx,%rsi,8)
jne 0xe173
leaq 0x1(,%rax,2), %rdx
addq %rax, %rax
movq %rdx, (%rcx,%rbx,8)
movq 0x3b8(%r15), %rcx
movq (%rcx,%rbx,8), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2d3d6
movq 0x3b8(%r15), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0x3b8(%r15), %rax
movq 0x3c0(%r15), %rcx
movq (%rax,%rbx,8), %rax
movq (%rcx,%rbx,8), %rdx
movq %r14, (%rax,%rdx,8)
incq (%rcx,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe1c7
movq 0x8(%rcx), %rax
movq %rsi, %r9
shrq $0x6, %r9
movq (%rax,%r9,8), %rax
btq %rsi, %rax
jae 0xe1c7
movq %rsi, %rcx
movq %rdx, %rsi
jmp 0xe1e9
movl $0x1, %eax
cmpq %rdx, %r8
jbe 0xe246
movq 0x8(%rcx), %rcx
movq %rdx, %r8
shrq $0x6, %r8
movq (%rcx,%r8,8), %rcx
btq %rdx, %rcx
movq %rdx, %rcx
jae 0xe246
leaq 0x51fd0(%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 0x51c68(%rip), %r8      # 0x5fe70
leaq (%rax,%rdx,4), %r9
movl (%r8,%r9), %r9d
cmpq %r9, %rcx
je 0xe238
imulq 0x3d0(%rdi), %r9
addq %rsi, %r9
movq 0x3b0(%rdi), %r10
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe247
incq %rdx
cmpq $0x7, %rdx
jne 0xe208
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe30a
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 0xe2da
movq 0x8(%rcx), %r10
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe30d
movq 0x458(%rdi), %r10
movq (%r10), %r11
shlq $0x6, %r11
cmpq %r9, %r11
jbe 0xe302
movq 0x8(%r10), %r10
movq %r9, %r11
shrq $0x6, %r11
movq (%r10,%r11,8), %r10
btq %r9, %r10
jb 0xe30d
incq %r8
cmpq %r8, %rax
jne 0xe2b9
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x52b66(%rip), %rax     # 0x60e80
movq (%rax), %rax
movq (%rax,%rsi,8), %rax
leaq 0x4a0(%rdi), %rcx
cmpq %rcx, 0x8(%rax)
je 0xe35f
movq 0x4b0(%rdi), %rcx
movq (%rcx), %rdx
shlq $0x6, %rdx
movl $0x1, %eax
cmpq %rsi, %rdx
jbe 0xe35e
movq 0x8(%rcx), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rcx
xorl %eax, %eax
btq %rsi, %rcx
setae %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rsp), %rdx
callq 0xe67e
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xe666
movq 0x8(%rsp), %r13
leaq 0x450(%rbx), %r15
leaq 0x448(%rbx), %r12
leaq 0x460(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x468(%rbx), %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
movq 0x440(%rbx), %rcx
movq (%r13,%rbp,8), %rax
movq (%rax), %rax
movq (%rcx), %rdx
shlq $0x6, %rdx
cmpq %rax, %rdx
jbe 0xe658
movq 0x8(%rcx), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
btq %rax, %rcx
jae 0xe658
cmpq $0x0, (%r15)
je 0xe658
xorl %r14d, %r14d
movq (%r13,%rbp,8), %rax
movq (%r12), %rcx
cmpq (%rcx,%r14,8), %rax
jne 0xe650
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d4cc
movq (%r13,%rbp,8), %rdx
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d3ff
movq 0x440(%rbx), %rdi
movq (%r13,%rbp,8), %rax
movq (%rax), %rsi
callq 0x2d872
movq 0x458(%rbx), %rdi
movq (%r13,%rbp,8), %rax
movq (%rax), %rsi
callq 0x2d816
incq %r14
cmpq (%r15), %r14
jb 0xe5f7
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0xe5be
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x408(%rdi), %rax
movq (%rax,%rsi,8), %r12
leaq (,%r12,8), %rdi
callq 0x4280
testq %r12, %r12
je 0xe725
movq 0x400(%r15), %rdx
movq 0x440(%r15), %rsi
movq (%rsi), %rdi
shlq $0x6, %rdi
xorl %r8d, %r8d
xorl %ecx, %ecx
movq (%rdx,%r14,8), %r9
movq (%r9,%r8,8), %r9
movq (%r9), %r10
cmpq %r10, %rdi
jbe 0xe6ec
movq 0x8(%rsi), %r11
movq %r10, %r13
shrq $0x6, %r13
movq (%r11,%r13,8), %r11
btq %r10, %r11
jb 0xe714
movq 0x458(%r15), %r11
movq (%r11), %r13
shlq $0x6, %r13
cmpq %r10, %r13
jbe 0xe71b
movq 0x8(%r11), %r11
movq %r10, %r13
shrq $0x6, %r13
movq (%r11,%r13,8), %r11
btq %r10, %r11
jae 0xe71b
movq %r9, (%rax,%rcx,8)
incq %rcx
incq %r8
cmpq %r8, %r12
jne 0xe6c7
jmp 0xe727
xorl %ecx, %ecx
movq %rax, (%rbx)
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4c0(%rdi), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %rsi, %rcx
jbe 0xe771
movq 0x8(%rax), %rax
movq %r14, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r14, %rax
jb 0xe844
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe28d
testl %eax, %eax
jne 0xe844
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe24a
testl %eax, %eax
je 0xe844
leaq 0x526e2(%rip), %r12     # 0x60e80
movq (%r12), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rax
leaq 0x480(%rbx), %rdi
cmpq %rdi, %rax
sete %cl
leaq 0x490(%rbx), %r15
cmpq %r15, %rax
sete %al
orb %cl, %al
je 0xe850
movq 0x480(%rbx), %rax
movq 0x488(%rbx), %rsi
movq $-0x1, %rdx
testq %rsi, %rsi
je 0xe800
xorl %r8d, %r8d
movq (%rax,%r8,8), %rcx
cmpq %r14, 0x10(%rcx)
setne %cl
je 0xe804
incq %r8
cmpq %r8, %rsi
jne 0xe7e9
jmp 0xe807
movb $0x1, %cl
jmp 0xe807
movq %r8, %rdx
testb %cl, %cl
jne 0xe823
leaq 0x488(%rbx), %rsi
movq (%rax,%rdx,8), %rax
movq $0x0, 0x8(%rax)
callq 0x2d4cc
addq $0x498, %rbx            # imm = 0x498
movq (%r12), %rax
movq (%rax,%r14,8), %r14
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d3ff
movq %r15, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x23773(%rip), %rdi     # 0x31fca
leaq 0x23656(%rip), %rsi     # 0x31eb4
leaq 0x237a6(%rip), %rcx     # 0x3200b
movl $0x336, %edx            # imm = 0x336
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rcx), %rsi
movq (%rdx), %rax
shlq $0x6, %rax
xorl %ebp, %ebp
cmpq %rsi, %rax
jbe 0xeb3f
movq %rcx, %r14
movq 0x8(%rdx), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0xeb3f
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2d872
movq (%rbx), %rax
testq %rax, %rax
je 0xeb3f
movq (%r15), %rcx
xorl %edx, %edx
cmpq %r14, (%rcx,%rdx,8)
je 0xeb2f
incq %rdx
cmpq %rdx, %rax
jne 0xeb1d
xorl %ebp, %ebp
jmp 0xeb3f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2d4cc
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/ra.c
// Function: mapfind
static Loc *
mapfind(Isel *s, Htab *map, Loc *old)
{
	Loc *new;
	Loc *base;
	Loc *idx;
	regid id;

	if (!old)
		return NULL;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xec13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xec1a
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rax
testq %rdx, %rdx
je 0xec67
leaq 0x5229f(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq 0x10(%rdx), %rdx
movq 0x3d0(%r15), %rsi
cmpq %rdx, %rsi
jbe 0xec0d
movq 0x3e8(%r15), %rdi
movq (%rdi,%rdx,8), %r8
testq %r8, %r8
je 0xec0d
movq 0x10(%r8), %rdx
cmpq %rsi, %rdx
jb 0xebfb
movq (%rcx,%rdx,8), %rdx
jmp 0xec69
xorl %ebx, %ebx
jmp 0xed10
cmpl $0x2, %eax
jne 0xecef
movq 0x10(%rbx), %rax
movq 0x3d0(%r15), %rcx
cmpq %rax, %rcx
jbe 0xec4c
movq 0x3e8(%r15), %rdx
movq (%rdx,%rax,8), %rsi
testq %rsi, %rsi
je 0xec4c
movq 0x10(%rsi), %rax
cmpq %rcx, %rax
jb 0xec3a
leaq 0x5222d(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x2dd9a
jmp 0xed09
xorl %edx, %edx
testq %rax, %rax
je 0xeca7
leaq 0x5220b(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq 0x10(%rax), %rax
movq 0x3d0(%r15), %rsi
cmpq %rax, %rsi
jbe 0xeca1
movq 0x3e8(%r15), %rdi
movq (%rdi,%rax,8), %r8
testq %r8, %r8
je 0xeca1
movq 0x10(%r8), %rax
cmpq %rsi, %rax
jb 0xec8f
movq (%rcx,%rax,8), %r13
jmp 0xecaa
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0xeba8
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xeba8
cmpq 0x28(%rbx), %r12
jne 0xecd2
cmpq 0x30(%rbx), %rax
je 0xecef
cmpl $0x3, (%rbx)
jne 0xecf3
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0xaaec
jmp 0xed09
xorl %eax, %eax
jmp 0xed09
movq 0x10(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0xab80
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/peep.c
// Function: peep
void
peep(Isel *s)
{
	size_t i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0xee58
movq 0x18(%rdi), %rbx
movl $0x1, %r12d
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %r13
testq %r13, %r13
je 0xee49
movq 0x20(%r13), %rcx
testq %rcx, %rcx
je 0xed8c
movq 0x18(%r13), %rdx
movq %rcx, %rsi
negq %rsi
movl $0x1, %eax
movq -0x8(%rdx,%rax,8), %rdi
cmpl $0x34, 0x8(%rdi)
je 0xed8e
leaq (%rsi,%rax), %rdi
incq %rdi
incq %rax
cmpq $0x1, %rdi
jne 0xed6c
movq %rcx, %rax
jmp 0xed8e
xorl %eax, %eax
movq %rax, 0x20(%r13)
testq %r13, %r13
je 0xee49
movq 0x20(%r13), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0xee49
movq 0x18(%r13), %rax
movq 0x8(%rsp), %rcx
movq -0x8(%rax,%rcx,8), %rax
cmpl $0x34, 0x8(%rax)
jne 0xedd3
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
movl $0x0, %ecx
cmovneq %rcx, %rax
jmp 0xedd5
xorl %eax, %eax
testq %rax, %rax
je 0xee49
movq %r12, %rdx
cmpq %r14, %rdx
jae 0xedf0
movq (%rbx,%rdx,8), %rcx
incq %rdx
testq %rcx, %rcx
je 0xeddd
jmp 0xedf2
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xee49
movq 0x10(%rcx), %rdx
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
je 0xee49
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4230
testl %eax, %eax
je 0xee3d
incq %r15
cmpq %r15, 0x20(%rsp)
jne 0xee1a
jmp 0xee49
movq 0x8(%rsp), %rax
decq %rax
movq %rax, 0x20(%r13)
incq %rbp
incq %r12
cmpq %r14, %rbp
jne 0xed47
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: loadvar
Node *
loadvar(Simp *s, Node *n, Node *dst)
{
	Node *p, *f, *r, *e;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28e87
testl %eax, %eax
je 0xef39
testq %rbx, %rbx
jne 0xeed7
movq %r14, %rdi
movq %r15, %rsi
callq 0xef46
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0xefb4
movq %rax, %r12
movq %r15, %rdi
callq 0x1e5d4
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf094
movq %rax, %r13
movl $0x8, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0xf157
movq (%r15), %rdi
xorl %esi, %esi
callq 0x1d7ca
movq 0x52406(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xf157
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: temp
static Node *
temp(Simp *simp, Node *e)
{
	Node *t, *dcl;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x8, 0x8(%rsi)
jne 0xef95
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x20(%rsi), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1e345
movq %rax, %r14
movq %r15, %rdi
callq 0xee80
testl %eax, %eax
je 0xef88
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7c2
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21dac(%rip), %rdi     # 0x30d48
leaq 0x23331(%rip), %rsi     # 0x322d4
leaq 0x23331(%rip), %rcx     # 0x322db
movl $0x11c, %edx            # imm = 0x11C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: getcode
static Node *
getcode(Simp *s, Node *n)
{
	Node *r, *p, *d;
	Type *ty;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28e87
testl %eax, %eax
je 0xf01d
leaq 0x52996(%rip), %rax     # 0x61968
movq (%rax), %rax
movq (%rbx), %rdi
movq 0x38(%rbx), %rcx
movq (%rax,%rcx,8), %r15
movq 0x50(%rbx), %rax
movq (%rax), %rdx
movl $0x33, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x55ef
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
cmpl $0x13, (%rax)
jne 0xf075
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xfb13
movq %rax, %rbx
movq %r15, %rdi
callq 0x55ef
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf094
movl $0x8, %esi
movq %rax, %rdi
callq 0x10c3a
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10bc3
leaq 0x233ff(%rip), %rdi     # 0x3247b
leaq 0x23251(%rip), %rsi     # 0x322d4
leaq 0x23404(%rip), %rcx     # 0x3248e
movl $0x41e, %edx            # imm = 0x41E
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: addr
static Node *
addr(Simp *s, Node *a, Type *bt)
{
	Node *n;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
movl $0x12, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %rbx
movl 0x8(%r15), %eax
cmpl $0xb, %eax
je 0xf0d7
cmpl $0x8, %eax
jne 0xf115
movq %r15, %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0xf115
movq 0x50(%r12), %rdi
movq %r15, %rsi
callq 0x2decd
movl $0x1, %ebp
testl %eax, %eax
jne 0xf11f
movq 0x48(%r12), %rdi
movq %r15, %rsi
callq 0x2decd
testl %eax, %eax
jne 0xf11f
movq 0x40(%r12), %rdi
movq %r15, %rsi
callq 0x2decd
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0xf11f
movq %r15, %rdi
callq 0xee80
movl %eax, %ebp
testl %ebp, %ebp
jne 0xf12e
movq %r12, %rdi
movq %r15, %rsi
callq 0xf834
testq %r14, %r14
je 0xf13b
movq (%r15), %rdi
movq %r14, %rsi
jmp 0xf142
movq (%r15), %rdi
movq 0x20(%r15), %rsi
callq 0x231bc
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: assignat
static Node *
assignat(Simp *s, Node *r, size_t off, Node *val)
{
	Node *pval, *pdst;
	Node *sz;
	Node *st;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rcx), %rdi
movl %edx, %esi
callq 0x1d7ca
movq 0x521ae(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf90b
movq %rax, %r12
movq %r15, %rdi
callq 0xee80
testl %eax, %eax
je 0xf1eb
movq %r15, %rdi
callq 0x1281a
movq (%r15), %rdi
movl %eax, %esi
callq 0x1d7ca
movq %rax, %r13
movq 0x52174(%rip), %rax     # 0x61328
movq %rax, 0x20(%r13)
movq %r15, %rdi
callq 0x1e5d4
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xf094
movq (%r15), %rdi
movl $0x46, %esi
movq %r12, %rdx
movq %rax, %rcx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d832
jmp 0xf202
movq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0xfa23
movq %rax, %rdi
movq %r15, %rsi
callq 0xf970
movq %r14, %rdi
movq %rax, %rsi
callq 0xfaab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq