LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: encodemin
static void
encodemin(FILE *fd, uvlong val)
{
	size_t i, shift;
	uint8_t b;

	if (val < 128) {
		fprintf(fd, "\t.byte %llu\n", val);
		return;
	}

	for (i = 1; i < 8; i++)
		if (val < 1ULL << (7*i))
			break;
	shift = 8 - i;
	b = ~0ull << (shift + 1);
	b |= val & ~(~0ull << shift);
	fprintf(fd, "\t.byte %u\n", b);
	val >>=  shift;
	while (val != 0) {
		fprintf(fd, "\t.byte %u\n", (uint)val & 0xff);
		val >>= 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x80, -0x10(%rbp)
jae 0x9115
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x429b5(%rip), %rsi     # 0x4babe
movb $0x0, %al
callq 0x6230
jmp 0x91f4
movq $0x1, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x914f
movq -0x10(%rbp), %rax
imulq $0x7, -0x18(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0x913f
jmp 0x914f
jmp 0x9141
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x911d
movl $0x8, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq $-0x1, %rax
shlq %cl, %rax
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq $-0x1, %rax
shlq %cl, %rax
movq -0x30(%rbp), %rcx
xorq $-0x1, %rax
andq %rax, %rcx
movzbl -0x21(%rbp), %eax
orq %rcx, %rax
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x21(%rbp), %edx
leaq 0x429c1(%rip), %rsi     # 0x4bb6c
movb $0x0, %al
callq 0x6230
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
shrq %cl, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x91f4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %edx
andl $0xff, %edx
leaq 0x4298d(%rip), %rsi     # 0x4bb6c
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x91c1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: writeasm
static void
writeasm(FILE *fd, Isel *s, Func *fn)
{
	size_t i, j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x73acd(%rip), %rax     # 0x7cce8
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x9230
jmp 0x9226
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x924b
jmp 0x925f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x42948(%rip), %rsi     # 0x4bb8a
movb $0x0, %al
callq 0x6230
jmp 0x926d
movq -0x8(%rbp), %rdi
leaq 0x42949(%rip), %rsi     # 0x4bb9f
movb $0x0, %al
callq 0x6230
jmp 0x926d
leaq 0x42064(%rip), %rdi     # 0x4b2ca
movb $0x0, %al
callq 0x1df20
movq -0x18(%rbp), %rax
cmpb $0x0, 0x58(%rax)
je 0x9290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x42165(%rip), %rsi     # 0x4b3ee
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x42817(%rip), %rsi     # 0x4bab9
movb $0x0, %al
callq 0x6230
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x20(%rcx), %rax
jae 0x93a5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x92df
jmp 0x9394
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x10(%rcx), %rax
jae 0x933d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x42791(%rip), %rsi     # 0x4bab9
movb $0x0, %al
callq 0x6230
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x92e7
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x20(%rcx), %rax
jae 0x9392
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x81d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9345
jmp 0x9394
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x92b1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/gengas.c
// Function: gentype
static void
gentype(FILE *fd, Type *ty)
{
	Blob *b;

	ty = tydedup(ty);
	if (ty->type == Tyvar || ty->isemitted)
		return;

	ty->isemitted = 1;
	b = tydescblob(ty);
	if (b->isglobl)
		b->iscomdat = 1;
	if (asmsyntax == Gnugaself)
		fprintf(fd, ".section .data.%s,\"aw\",@progbits\n", b->lbl);
	writeblob(fd, b);
	blobfree(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36b70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
je 0x93e6
movq -0x10(%rbp), %rax
movsbl 0x96(%rax), %eax
cmpl $0x0, %eax
je 0x93e8
jmp 0x944e
movq -0x10(%rbp), %rax
movb $0x1, 0x96(%rax)
movq -0x10(%rbp), %rdi
callq 0x1bfa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x9412
movq -0x18(%rbp), %rax
movb $0x1, 0x19(%rax)
leaq 0x738cf(%rip), %rax     # 0x7cce8
cmpl $0x0, (%rax)
jne 0x9438
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x41fc8(%rip), %rsi     # 0x4b3f9
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8820
movq -0x18(%rbp), %rdi
callq 0x6610
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: genblob
static void
genblob(FILE *fd, Node *blob, Htab *globls, Htab *strtab)
{
	char *lbl;
	Blob *b;

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

	lbl = htget(globls, blob);
	fprintf(fd, "GLOBL %s+0(SB),$%llu\n", lbl, (uvlong)size(blob));
	if (blob->decl.init)
		b = litblob(globls, strtab, blob->decl.init);
	else
		b = mkblobpad(size(blob));
	writeblob(fd, b, 0, lbl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0x96c4
jmp 0x96e3
leaq 0x41ce2(%rip), %rdi     # 0x4b3ad
leaq 0x42692(%rip), %rsi     # 0x4bd64
movl $0x19b, %edx            # imm = 0x19B
leaq 0x41ce3(%rip), %rcx     # 0x4b3c1
callq 0x6160
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x4264d(%rip), %rsi     # 0x4bd6c
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x974c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x66e0
movq %rax, -0x30(%rbp)
jmp 0x9761
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, %rdi
callq 0x64c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x9a30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: genfunc
static void
genfunc(FILE *fd, Func *fn, Htab *globls, Htab *strtab)
{
	Isel is = {0,};

	is.reglocs = mkht(varhash, vareq);
	is.name = fn->name;
	is.stkoff = fn->stkoff;
	is.envoff = fn->envoff;
	is.globls = globls;
	is.ret = fn->ret;
	is.rettype = fn->rettype;
	is.cfg = fn->cfg;
	if (fn->hasenv)
		is.envp = locreg(ModeQ);

	selfunc(&is, fn, globls, strtab);
	if (debugopt['i'])
		writeasm(stdout, &is, fn);
	writeasm(fd, &is, fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x4f0(%rbp), %rdi
xorl %esi, %esi
movl $0x4d0, %edx            # imm = 0x4D0
callq 0x6180
leaq 0x2701b(%rip), %rdi     # 0x307d0
leaq 0x270e4(%rip), %rsi     # 0x308a0
callq 0x48fe0
movq %rax, -0x4a8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x4f0(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x4a0(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x498(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x490(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x4c0(%rbp)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x4b8(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x4e0(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x59(%rax)
je 0x9845
movl $0x4, %edi
callq 0xff10
movq %rax, -0x488(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x4f0(%rbp), %rdi
callq 0xe1e0
leaq 0x7349c(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x69(%rax)
je 0x9884
movq 0x5575f(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq -0x4f0(%rbp), %rsi
callq 0x9fd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x4f0(%rbp), %rsi
callq 0x9fd0
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: genstrings
static void
genstrings(FILE *fd, Htab *strtab)
{
	void **k;
	char *lbl;
	Str *s;
	size_t i, nk;

	k = htkeys(strtab, &nk);
	for (i = 0; i < nk; i++) {
		s = k[i];
		lbl = htget(strtab, k[i]);
		if (s->len) {
			fprintf(fd, "GLOBL %s+0(SB),2,$%lld\n", lbl, (vlong)s->len);
			writebytes(fd, lbl, 0, s->buf, s->len);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x49720
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x9a2a
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a17
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x42925(%rip), %rsi     # 0x4c315
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x9e40
jmp 0x9a19
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9999
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: encodemin
static size_t
encodemin(FILE *fd, uvlong val, size_t off, char *lbl)
{
	size_t i, shift, n;
	uint8_t b;

	if (val < 128) {
		fprintf(fd, "\tDATA %s+%llu(SB)/1,$%u // single\n", lbl, (uvlong)off, (unsigned)val);
		return 1;
	}

	for (i = 1; i < 8; i++)
		if (val < 1ULL << (7*i))
			break;

	n = 0;
	shift = 8 - i;
	b = ~0ull << (shift + 1);
	b |= val & ~(~0ull << shift);
	fprintf(fd, "\tDATA %s+%llu(SB)/1,$%u //first\n", lbl, (uvlong)off, b);
	val >>=  shift;
	while (val != 0) {
		n++;
		fprintf(fd, "\tDATA %s+%llu(SB)/1,$%llu // tail\n", lbl, (uvlong)off+n, (uvlong)val & 0xff);
		val >>= 8;
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0x9d20
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl %eax, %r8d
leaq 0x42128(%rip), %rsi     # 0x4be34
movb $0x0, %al
callq 0x6230
movq $0x1, -0x8(%rbp)
jmp 0x9e2f
movq $0x1, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x9d5a
movq -0x18(%rbp), %rax
imulq $0x7, -0x30(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9d4a
jmp 0x9d5a
jmp 0x9d4c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9d28
movq $0x0, -0x40(%rbp)
movl $0x8, %eax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
addq $0x1, %rcx
movq $-0x1, %rax
shlq %cl, %rax
movb %al, -0x41(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rcx
movq $-0x1, %rax
shlq %cl, %rax
movq -0x50(%rbp), %rcx
xorq $-0x1, %rax
andq %rax, %rcx
movzbl -0x41(%rbp), %eax
orq %rcx, %rax
movb %al, -0x41(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzbl -0x41(%rbp), %r8d
leaq 0x42090(%rip), %rsi     # 0x4be57
movb $0x0, %al
callq 0x6230
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
shrq %cl, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9e27
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq -0x40(%rbp), %rcx
movq -0x18(%rbp), %r8
andq $0xff, %r8
leaq 0x42066(%rip), %rsi     # 0x4be78
movb $0x0, %al
callq 0x6230
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x9ddd
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: writebytes
static size_t
writebytes(FILE *fd, char *name, size_t off, char *p, size_t sz)
{
	size_t i, len;

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

	return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9e65
jmp 0x9e84
leaq 0x4202f(%rip), %rdi     # 0x4be9b
leaq 0x41ef1(%rip), %rsi     # 0x4bd64
movl $0xc5, %edx
leaq 0x42024(%rip), %rcx     # 0x4bea3
callq 0x6160
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x9fc1
movq -0x28(%rbp), %rdi
subq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x4a580
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x9ee0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x42004(%rip), %rsi     # 0x4bedd
movb $0x0, %al
callq 0x6230
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x9f02
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x9f14
movq -0x8(%rbp), %rdi
leaq 0x41b95(%rip), %rsi     # 0x4baa2
movb $0x0, %al
callq 0x6230
callq 0x6370
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x9f59
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x49be4(%rip), %rsi     # 0x53b34
movb $0x0, %al
callq 0x6230
jmp 0x9f7d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl $0xff, %edx
leaq 0x41b2e(%rip), %rsi     # 0x4baa4
movb $0x0, %al
callq 0x6230
movq -0x30(%rbp), %rax
andq $0x7, %rax
cmpq $0x7, %rax
je 0x9f9c
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x9fae
movq -0x8(%rbp), %rdi
leaq 0x4226d(%rip), %rsi     # 0x4c214
movb $0x0, %al
callq 0x6230
jmp 0x9fb0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9e8c
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: writeasm
static void
writeasm(FILE *fd, Isel *s, Func *fn)
{
	size_t i, j;
	char *hidden;

	hidden = "";
	if (fn->isexport)
		hidden = "";
	/* we don't use the stack size directive: myrddin handle
	 * the stack frobbing on its own */
	fprintf(fd, "TEXT %s%s+0(SB),2,$0\n", fn->name, hidden);
	for (j = 0; j < s->cfg->nbb; j++) {
		if (!s->bb[j])
			continue;
		for (i = 0; i < s->bb[j]->nlbls; i++)
			fprintf(fd, "%s:\n", s->bb[j]->lbls[i]);
		for (i = 0; i < s->bb[j]->ni; i++)
			iprintf(fd, s->bb[j]->il[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4b83a(%rip), %rax     # 0x55825
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x58(%rax)
je 0xa004
leaq 0x4b825(%rip), %rax     # 0x55825
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rcx
leaq 0x41edd(%rip), %rsi     # 0x4bef7
movb $0x0, %al
callq 0x6230
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x20(%rcx), %rax
jae 0xa11d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa057
jmp 0xa10c
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa0b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x41a19(%rip), %rsi     # 0x4bab9
movb $0x0, %al
callq 0x6230
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa05f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x20(%rcx), %rax
jae 0xa10a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xa130
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa0bd
jmp 0xa10c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa029
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: printmem
static void
printmem(FILE *fd, Loc *l, char spec)
{
	if (l->type == Locmem) {
		if (l->mem.constdisp)
			fprintf(fd, "%ld", l->mem.constdisp);
	} else if (l->mem.lbldisp) {
		fprintf(fd, "%s", l->mem.lbldisp);
	}
	if (!l->mem.base || l->mem.base->reg.colour == Rrip) {
		fprintf(fd, "+0(SB)");
	} else {
		fprintf(fd, "(");
		locprint(fd, l->mem.base, 'r');
		fprintf(fd, ")");
	}
	if (l->mem.idx) {
		fprintf(fd, "(");
		locprint(fd, l->mem.idx, 'r');
		fprintf(fd, "*%d", l->mem.scale);
		fprintf(fd, ")");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xa705
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa703
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x40e8d(%rip), %rsi     # 0x4b589
movb $0x0, %al
callq 0x6230
jmp 0xa72c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa72a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x48378(%rip), %rsi     # 0x52a9b
movb $0x0, %al
callq 0x6230
jmp 0xa72c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xa745
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x65, 0x18(%rax)
jne 0xa759
movq -0x8(%rbp), %rdi
leaq 0x41b79(%rip), %rsi     # 0x4c2c9
movb $0x0, %al
callq 0x6230
jmp 0xa793
movq -0x8(%rbp), %rdi
leaq 0x46b46(%rip), %rsi     # 0x512aa
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x72, %edx
callq 0xa400
movq -0x8(%rbp), %rdi
leaq 0x48c5b(%rip), %rsi     # 0x533e7
movb $0x0, %al
callq 0x6230
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa7f1
movq -0x8(%rbp), %rdi
leaq 0x46b01(%rip), %rsi     # 0x512aa
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x72, %edx
callq 0xa400
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
leaq 0x41af8(%rip), %rsi     # 0x4c2d0
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
leaq 0x48bfd(%rip), %rsi     # 0x533e7
movb $0x0, %al
callq 0x6230
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/genp9.c
// Function: gentype
static void
gentype(FILE *fd, Type *ty)
{
	Blob *b;
	char lbl[1024];

	ty = tydedup(ty);
	if (ty->type == Tyvar || ty->isemitted)
		return;

	ty->isemitted = 1;
	b = tydescblob(ty);
	if (!b)
		return;
	if (b->isglobl) {
		fprintf(fd, "GLOBL %s%s+0(SB),2,$%llu\n", Symprefix, b->lbl, (uvlong)blobsz(b));
		bprintf(lbl, sizeof lbl, "%s%s", Symprefix, b->lbl);
	} else {
		fprintf(fd, "GLOBL %s%s<>+0(SB),2,$%llu\n", Symprefix, b->lbl, (uvlong)blobsz(b));
		bprintf(lbl, sizeof lbl, "%s%s<>", Symprefix, b->lbl);
	}
	writeblob(fd, b, 0, lbl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36b70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
je 0xa839
movq -0x10(%rbp), %rax
movsbl 0x96(%rax), %eax
cmpl $0x0, %eax
je 0xa83e
jmp 0xa96a
movq -0x10(%rbp), %rax
movb $0x1, 0x96(%rax)
movq -0x10(%rbp), %rdi
callq 0x1bfa0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa862
jmp 0xa96a
movq -0x18(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0xa8e0
movq -0x8(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b540
movq -0x430(%rbp), %rdi
movq -0x428(%rbp), %rcx
movq %rax, %r8
leaq 0x41a31(%rip), %rsi     # 0x4c2d8
leaq 0x4af77(%rip), %rdx     # 0x55825
movb $0x0, %al
callq 0x6230
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x43210(%rip), %rdx     # 0x4dae0
leaq 0x4af4e(%rip), %rcx     # 0x55825
movb $0x0, %al
callq 0x4a230
jmp 0xa952
movq -0x8(%rbp), %rax
movq %rax, -0x440(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x438(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b540
movq -0x440(%rbp), %rdi
movq -0x438(%rbp), %rcx
movq %rax, %r8
leaq 0x419d7(%rip), %rsi     # 0x4c2f2
leaq 0x4af03(%rip), %rdx     # 0x55825
movb $0x0, %al
callq 0x6230
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x419ca(%rip), %rdx     # 0x4c30e
leaq 0x4aeda(%rip), %rcx     # 0x55825
movb $0x0, %al
callq 0x4a230
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x420(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x9a30
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: mkinsnv
static Insn *
mkinsnv(AsmOp op, va_list ap)
{
	Loc *l;
	Insn *i;
	int n;
	static size_t insnid;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x38, %edi
callq 0x6280
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq 0x71f43(%rip), %rcx     # 0x7c998
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x71f35(%rip)     # 0x7c998
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x28, %eax
ja 0xaa95
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rbp)
jmp 0xaaac
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xaada
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
jmp 0xaa6a
movslq -0x24(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: binop
static Loc *
binop(Isel *s, AsmOp op, Node *x, Node *y)
{
	Loc *a, *b;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xaaf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaaf0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc070
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: g
static void
g(Isel *s, int op, ...)
{
	va_list ap;
	Insn *i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xbfbb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0xc(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0xaa20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq 0x70ce3(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x69(%rax)
je 0xc04b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
leaq 0x406e3(%rip), %rdi     # 0x4c714
movb $0x0, %al
callq 0x6120
movq 0x52f91(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x9010
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
movq -0x38(%rbp), %rdx
callq 0x48290
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: newr
static Loc *
newr(Isel *s, Loc *a)
{
	Loc *r;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xff10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xc0e8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xfd70
cmpl $0x0, %eax
je 0xc0c9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xc0e6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xc0f9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf200
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: mode
static Mode
mode(Node *n)
{
	if (n->type == Nexpr)
		return tymode(exprtype(n));
	else if (n->type == Ndecl)
		return tymode(n->decl.type);
	else
		die("invalid node type");
	return ModeNone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0xc13c
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0xf2c0
movl %eax, -0x4(%rbp)
jmp 0xc166
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0xc158
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xf2c0
movl %eax, -0x4(%rbp)
jmp 0xc166
leaq 0x405f5(%rip), %rdi     # 0x4c754
movb $0x0, %al
callq 0x1df20
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x3c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x2, %eax
jne 0xc293
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xaaf0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xf380
cmpl $0x0, %eax
je 0xc1f8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0xaaf0
movq %rax, -0x38(%rbp)
jmp 0xc20d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xaaf0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
je 0xc227
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf40
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xc253
movslq -0x3c(%rbp), %rdi
movq -0x38(%rbp), %rax
imulq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x28(%rbp)
jmp 0xc291
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xbf40
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xbf40
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movl -0x14(%rbp), %r8d
xorl %eax, %eax
movl %eax, %edi
callq 0x100d0
movq %rax, -0x28(%rbp)
jmp 0xc2cc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xaaf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xbf40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x10050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc2d5
jmp 0xc2f4
leaq 0x46bf2(%rip), %rdi     # 0x52ece
leaq 0x403b3(%rip), %rsi     # 0x4c696
movl $0x1d3, %edx            # imm = 0x1D3
leaq 0x40477(%rip), %rcx     # 0x4c766
callq 0x6160
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x52985(%rip), %rax     # 0x5fd80
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x52962(%rip), %rax     # 0x5fd80
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xd493
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0xaaf0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x2, 0x40(%rax)
jne 0xd478
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xaaf0
movq %rax, -0x28(%rbp)
jmp 0xd480
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc070
movq %rax, -0x20(%rbp)
jmp 0xd4d1
movl $0x19, -0x3c(%rbp)
movl $0x36, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xaaf0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc070
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfe40
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfe40
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x34, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xbf80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0xd5a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf980
movq %rax, -0x28(%rbp)
jmp 0xd72d
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0x33, %eax
je 0xd5cc
jmp 0xd5b5
movl -0x2c(%rbp), %eax
subl $0x35, %eax
je 0xd62b
jmp 0xd5bf
movl -0x2c(%rbp), %eax
subl $0x36, %eax
je 0xd5e2
jmp 0xd705
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf980
movq %rax, -0x28(%rbp)
jmp 0xd72b
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x377a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x101f0
movq %rax, -0x28(%rbp)
jmp 0xd72b
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x7, %rax
ja 0xd6e1
movq -0x40(%rbp), %rax
leaq 0x3eed6(%rip), %rcx     # 0x4c530
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, -0x28(%rbp)
jmp 0xd703
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x101f0
movq %rax, -0x28(%rbp)
jmp 0xd703
movq -0x18(%rbp), %rax
movslq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x101f0
movq %rax, -0x28(%rbp)
jmp 0xd703
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x101f0
movq %rax, -0x28(%rbp)
jmp 0xd703
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
leaq 0x6f13f(%rip), %rax     # 0x7c830
movq (%rax,%rcx,8), %rsi
leaq 0x3f1c1(%rip), %rdi     # 0x4c8bd
movb $0x0, %al
callq 0x1df20
jmp 0xd72b
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x6e7a7(%rip), %rax     # 0x7bec0
movq (%rax,%rcx,8), %rsi
leaq 0x3f1b8(%rip), %rdi     # 0x4c8dc
movb $0x0, %al
callq 0x1df20
jmp 0xd72d
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x10(%rbp), %rcx
leaq 0x3ee61(%rip), %rax     # 0x4c5d0
cmpl $0x0, (%rax,%rcx,4)
je 0xd777
jmp 0xd796
leaq 0x3f178(%rip), %rdi     # 0x4c8f6
leaq 0x3ef11(%rip), %rsi     # 0x4c696
movl $0x1e5, %edx            # imm = 0x1E5
leaq 0x3f180(%rip), %rcx     # 0x4c911
callq 0x6160
cmpq $0x0, -0x30(%rbp)
jne 0xd7a2
jmp 0xd8cc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xbf40
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf40
movq %rax, -0x50(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, 0x10(%rbp)
jne 0xd7db
movq $0x8, 0x10(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
leaq 0x3ede2(%rip), %rax     # 0x4c5d0
cmpl $0x0, (%rax,%rcx,4)
je 0xd8cc
movq -0x40(%rbp), %rcx
leaq 0x3edcd(%rip), %rax     # 0x4c5d0
movl (%rax,%rcx,4), %edi
callq 0xff10
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xd8ba
movq -0x38(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq 0x3ed98(%rip), %rax     # 0x4c5d0
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq 0x3ed71(%rip), %rax     # 0x4c5d0
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x68(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xd80f
jmp 0xd8bc
movq -0x40(%rbp), %rax
shrq %rax
movq %rax, -0x40(%rbp)
jmp 0xd7e3
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd920
movq $0x8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
leaq 0x3ec9d(%rip), %rax     # 0x4c5d0
cmpl $0x0, (%rax,%rcx,4)
je 0xd9df
movq -0x40(%rbp), %rcx
leaq 0x3ec88(%rip), %rax     # 0x4c5d0
movl (%rax,%rcx,4), %edi
callq 0xff10
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x13, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xd9cd
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq 0x3ec3e(%rip), %rax     # 0x4c5d0
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xd971
jmp 0xd9cf
movq -0x40(%rbp), %rax
shrq %rax
movq %rax, -0x40(%rbp)
jmp 0xd928
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xe05a
jmp 0xe079
leaq 0x3e7c3(%rip), %rdi     # 0x4c824
leaq 0x3e62e(%rip), %rsi     # 0x4c696
movl $0x4ba, %edx            # imm = 0x4BA
leaq 0x3e8dd(%rip), %rcx     # 0x4c951
callq 0x6160
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0xe0ec
jmp 0xe086
movl -0x34(%rbp), %eax
subl $0x2, %eax
jne 0xe144
jmp 0xe094
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x51c8e(%rip), %rax     # 0x5fd30
movq (%rax,%rcx,8), %rax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %edi
callq 0xfca0
movl -0x38(%rbp), %edi
movl %eax, %esi
callq 0x10240
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xe146
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq 0x51bf6(%rip), %rax     # 0x5fcf0
movq (%rax,%rcx,8), %rax
movl %eax, -0x3c(%rbp)
movl -0x18(%rbp), %edi
callq 0xfc30
movl -0x3c(%rbp), %edi
movl %eax, %esi
callq 0x10240
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xe146
jmp 0xe146
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, %edi
callq 0xff10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0xe18b
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xe19e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xe19e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfdf0
movq %rax, -0x18(%rbp)
jmp 0xe1bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x5, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x18(%rbp), %rsi
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %ecx
callq 0x10050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: mkasmbb
static Asmbb *
mkasmbb(Bb *bb)
{
	Asmbb *as;

	if (!bb)
		return NULL;
	as = zalloc(sizeof(Asmbb));
	as->id = bb->id;
	as->pred = bsdup(bb->pred);
	as->succ = bsdup(bb->succ);
	as->lbls = memdup(bb->lbls, bb->nlbls*sizeof(char*));
	as->nlbls = bb->nlbls;
	return as;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe630
movq $0x0, -0x8(%rbp)
jmp 0xe6b6
movl $0x58, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x486d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x486d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq