LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/gram.c
// Function: yy_stack_print
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x3fb9f(%rip), %r12     # 0x43ff0
movq (%r12), %rcx
leaq 0x30f7e(%rip), %rdi     # 0x353da
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x4330
cmpq %rbx, %r14
ja 0x448e
leaq 0x2c66d(%rip), %r15     # 0x30ae0
movswl (%r14), %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
addq $0x2, %r14
cmpq %rbx, %r14
jbe 0x4473
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: mkblobi
Blob *
mkblobi(Blobtype type, uint64_t ival)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = type;
	b->ival = ival;
	return b;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x38, %edi
callq 0x2d348
movl %ebp, (%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: mkblobbytes
Blob *
mkblobbytes(char *buf, size_t len)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btbytes;
	b->bytes.buf = buf;
	b->bytes.len = len;
	return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x2d348
movl $0x6, (%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: mkblobseq
Blob *
mkblobseq(Blob **sub, size_t nsub)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btseq;
	b->seq.sub = sub;
	b->seq.nsub = nsub;
	return b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x2d348
movl $0x7, (%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: mkblobref
Blob *
mkblobref(char *lbl, size_t off, int isextern)
{
	Blob *b;

	b = zalloc(sizeof(Blob));
	b->type = Btref;
	b->ref.str = strdup(lbl);
	b->ref.isextern = isextern;
	b->ref.off = off;
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x2d348
movq %rax, %r12
movl $0x5, (%rax)
movq %r15, %rdi
callq 0x4340
movq %rax, 0x20(%r12)
movb %bl, 0x28(%r12)
movq %r14, 0x30(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: blobfree
void
blobfree(Blob *b)
{
	size_t i;

	if (!b)
		return;
	switch (b->type) {
	case Btref:
		free(b->lbl);
		break;
	case Btseq:
		for (i = 0; i < b->seq.nsub; i++)

			blobfree(b->seq.sub[i]);
		break;
	default:
		break;
	}
	free(b);
}

// Assembly:
testq %rdi, %rdi
je 0x4acc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x4acd
cmpl $0x7, %eax
jne 0x4ad6
cmpq $0x0, 0x20(%rbx)
je 0x4ad6
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4a92
incq %r14
cmpq 0x20(%rbx), %r14
jb 0x4ab4
jmp 0x4ad6
retq
movq 0x10(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/blob.c
// Function: litblob
Blob *
litblob(Htab *globls, Htab *strtab, Node *n)
{
	Blob *b;

	b = mkblobseq(NULL, 0);
	blobrec(b, globls, strtab, n);
	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x2d348
movq %rax, %r12
movl $0x7, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4b40
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: fillglobls
void
fillglobls(Stab *st, Htab *globls)
{
	size_t i, j, nk, nns;
	void **k, **ns;
	Stab *stab;
	Node *s;

	k = htkeys(st->dcl, &nk);
	for (i = 0; i < nk; i++) {
		s = htget(st->dcl, k[i]);
		if (isconstfn(s))
			s->decl.type = codetype(s->decl.type);
		htput(globls, s, asmname(s));
	}
	free(k);

	ns = htkeys(file.ns, &nns);
	for (j = 0; j < nns; j++) {
		stab = htget(file.ns, ns[j]);
		k = htkeys(stab->dcl, &nk);
		for (i = 0; i < nk; i++) {
			s = htget(stab->dcl, k[i]);
			htput(globls, s, asmname(s));
		}
		free(k);
	}
	free(ns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x552a
xorl %r13d, %r13d
movq 0x18(%r14), %rdi
movq (%r15,%r13,8), %rsi
callq 0x2dd9a
movq %rax, %r12
movq %rax, %rdi
callq 0x28e87
testl %eax, %eax
je 0x550b
movq 0x28(%r12), %rdi
callq 0x55ef
movq %rax, 0x28(%r12)
movq %r12, %rdi
callq 0x5630
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2dbc2
incq %r13
cmpq (%rsp), %r13
jb 0x54e0
movq %r15, %rdi
callq 0x4040
leaq 0x5bd3f(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x2dedf
movq %rax, 0x8(%rsp)
cmpq $0x0, (%r15)
je 0x55d6
xorl %r15d, %r15d
leaq 0x5bd16(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rsi
callq 0x2dd9a
movq %rax, %r12
movq 0x18(%rax), %rdi
movq %rsp, %rsi
callq 0x2dedf
movq %rax, %r13
cmpq $0x0, (%rsp)
je 0x55c4
xorl %r14d, %r14d
movq 0x18(%r12), %rdi
movq (%r13,%r14,8), %rsi
callq 0x2dd9a
movq %rax, %rbp
movq %rax, %rdi
callq 0x5630
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2dbc2
incq %r14
cmpq (%rsp), %r14
jb 0x5593
movq %r13, %rdi
callq 0x4040
incq %r15
cmpq 0x10(%rsp), %r15
jb 0x555b
movq 0x8(%rsp), %rdi
callq 0x4040
addq $0x18, %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/gen.c
// Function: codetype
Type *
codetype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tycode)
		return ft;
	assert(ft->type == Tyfunc);
	ft = tydup(ft);
	ft->type = Tycode;
	return ft;
}

// Assembly:
pushq %rax
callq 0x22c44
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x5620
cmpl $0x1e, %ecx
je 0x562e
leaq 0x29c23(%rip), %rdi     # 0x2f22b
leaq 0x29c2f(%rip), %rsi     # 0x2f23e
leaq 0x29c2e(%rip), %rcx     # 0x2f244
movl $0x51, %edx
callq 0x4180
movq %rax, %rdi
callq 0x22dee
movl $0x1e, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: asmname
char *
asmname(Node *dcl)
{
	char buf[1024];
	char *vis, *pf, *ns, *name, *sep;
	Node *n;

	n = dcl->decl.name;
	pf = Symprefix;
	ns = n->name.ns;
	name = n->name.name;
	vis = "";
	sep = "";
	if (asmsyntax == Plan9)
		if (islocal(dcl))
			vis = "<>";
	if (!ns || !ns[0])
		ns = "";
	else
		sep = "$";
	if (name[0] == '.')
		pf = "";

	bprintf(buf, sizeof buf, "%s%s%s%s%s", pf, ns, sep, name, vis);
	return strdup(buf);
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rax
leaq 0x5bb89(%rip), %rdx     # 0x611c8
leaq 0x2c7f4(%rip), %r8      # 0x31e3a
cmpl $0x2, (%rdx)
movq %r8, %r10
jne 0x5676
cmpb $0x0, 0x70(%rdi)
movq %r8, %r10
jne 0x5676
cmpb $0x0, 0x77(%rdi)
movq %r8, %r10
jne 0x5676
cmpb $0x0, 0x74(%rdi)
leaq 0x2b08f(%rip), %rdx     # 0x306fa
leaq 0x2c7c8(%rip), %r10     # 0x31e3a
cmoveq %rdx, %r10
movq 0x20(%rcx), %r11
movq %r8, %r9
testq %rax, %rax
je 0x569e
cmpb $0x0, (%rax)
leaq 0x2c7ae(%rip), %rcx     # 0x31e3a
cmoveq %rcx, %rax
leaq 0x29bde(%rip), %r9      # 0x2f275
cmoveq %rcx, %r9
movq %rax, %r8
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
leaq 0x29bca(%rip), %rdx     # 0x2f277
leaq 0x2c786(%rip), %rcx     # 0x31e3a
movq %rsp, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x2e42e
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x4340
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: initconsts
void
initconsts(Htab *globls)
{
	Type *ty;
	Node *name;
	Node *dcl;

	tyintptr = mktype(Zloc, Tyuint64);
	tyword = mktype(Zloc, Tyuint);
	tyvoid = mktype(Zloc, Tyvoid);

	ty = mktyfunc(Zloc, NULL, 0, mktype(Zloc, Tyvoid));
	ty->type = Tycode;
	name = mknsname(Zloc, "_rt", "abort_oob");
	dcl = mkdecl(Zloc, name, ty);
	dcl->decl.isconst = 1;
	dcl->decl.isextern = 1;
	htput(globls, dcl, asmname(dcl));

	abortoob = mkexpr(Zloc, Ovar, name, NULL);
	abortoob->expr.type = ty;
	abortoob->expr.did = dcl->decl.did;
	abortoob->expr.isconst = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xe, %esi
callq 0x22d38
leaq 0x5bc28(%rip), %rcx     # 0x61328
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xc, %esi
callq 0x22d38
leaq 0x5bc17(%rip), %rcx     # 0x61330
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x22d38
leaq 0x5bc06(%rip), %rcx     # 0x61338
movq %rax, (%rcx)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x22d38
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x23245
movq %rax, %r14
movl $0x1e, (%rax)
leaq 0x29ab8(%rip), %rsi     # 0x2f21d
leaq 0x29ab5(%rip), %rdx     # 0x2f221
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1e22a
movq %rax, %r15
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rsi
movq %r14, %rdx
callq 0x1e29f
movq %rax, %r12
movb $0x1, %al
movb %al, 0x72(%r12)
movb %al, 0x74(%r12)
movq %r12, %rdi
callq 0x5630
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2dbc2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x33, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
leaq 0x5bb75(%rip), %rcx     # 0x61340
movq %rax, (%rcx)
movq %r14, 0x20(%rax)
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%rax)
movl $0x1, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: closuretype
Type *
closuretype(Type *ft)
{
	ft = tybase(ft);
	if (ft->type == Tyfunc)
		return ft;
	assert(ft->type == Tycode);
	ft = tydup(ft);
	ft->type = Tyfunc;
	return ft;
}

// Assembly:
pushq %rax
callq 0x22c44
movl (%rax), %ecx
cmpl $0x13, %ecx
je 0x580e
cmpl $0x1e, %ecx
jne 0x5810
movq %rax, %rdi
callq 0x22dee
movl $0x13, (%rax)
popq %rcx
retq
leaq 0x333a6(%rip), %rdi     # 0x38bbd
leaq 0x29a20(%rip), %rsi     # 0x2f23e
leaq 0x29a36(%rip), %rcx     # 0x2f25b
movl $0x5d, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: tydescid
char *
tydescid(char *buf, size_t bufsz, Type *ty)
{
	char *sep, *ns;
	char *p, *end;
	size_t i;

	sep = "";
	ns = "";
	p = buf;
	end = buf + bufsz;
	ty = tydedup(ty);
	if (ty->type == Tyname) {
		if (ty->name->name.ns) {
			ns = ty->name->name.ns;
			sep = "$";
		}
		if (ty->vis != Visintern || ty->isimport)
			p += bprintf(p, end - p, "_tydesc$%s%s%s", ns, sep, ty->name->name.name, ty->tid);
		else
			p += bprintf(p, end - p, "_tydesc$%s%s%s$%d", ns, sep, ty->name->name.name, ty->tid);
		for (i = 0; i < ty->narg; i++)
			p += tyidfmt(p, end - p, ty->arg[i]);
	} else {
		if (file.globls->name) {
			ns = file.globls->name;
			sep = "$";
		}
		bprintf(buf, bufsz, "_tydesc%s%s$%d",sep, ns, ty->tid);
	}
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x22cec
movq %rax, %r15
cmpl $0x1c, (%rax)
jne 0x58ac
movq 0x88(%r15), %rax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
leaq 0x2c5ad(%rip), %rdx     # 0x31e3a
leaq 0x299e1(%rip), %r8      # 0x2f275
cmoveq %rdx, %r8
cmoveq %rdx, %rcx
cmpl $0x0, 0x10(%r15)
je 0x58f1
leaq 0x299d8(%rip), %rdx     # 0x2f282
jmp 0x590b
leaq 0x5b9c5(%rip), %rax     # 0x61278
movq 0x90(%rax), %rax
movq 0x8(%rax), %r8
testq %r8, %r8
leaq 0x2c572(%rip), %rax     # 0x31e3a
leaq 0x299a6(%rip), %rcx     # 0x2f275
cmoveq %rax, %rcx
cmoveq %rax, %r8
movl 0x4(%r15), %r9d
leaq 0x299c1(%rip), %rdx     # 0x2f2a3
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2e42e
jmp 0x5958
cmpb $0x0, 0x94(%r15)
leaq 0x29991(%rip), %rsi     # 0x2f291
leaq 0x2997b(%rip), %rdx     # 0x2f282
cmoveq %rsi, %rdx
movq 0x20(%rax), %r9
movl 0x4(%r15), %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2e42e
cmpq $0x0, 0x48(%r15)
je 0x5958
movq %rax, %r12
addq %rbx, %r14
addq %rbx, %r12
xorl %r13d, %r13d
movq %r14, %rsi
subq %r12, %rsi
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
callq 0x24514
addq %rax, %r12
incq %r13
cmpq 0x48(%r15), %r13
jb 0x5936
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gen.c
// Function: gen
void
gen(char *out)
{
	FILE *fd;

	fd = fopen(out, "w");
	if (!fd)
		die("Couldn't open fd %s", out);

	switch (asmsyntax) {
	case Plan9:
		genp9(fd);
		break;
	case Gnugaself:
	case Gnugasmacho:
		gengas(fd);
		break;
	default:
		die("unknown target");  break;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x29f6f(%rip), %rsi     # 0x2f8e3
callq 0x42e0
testq %rax, %rax
je 0x599e
leaq 0x5b843(%rip), %rcx     # 0x611c8
cmpl $0x2, (%rcx)
jae 0x5993
movq %rax, %rdi
popq %rbx
jmp 0x63e6
jne 0x59af
movq %rax, %rdi
popq %rbx
jmp 0x6958
leaq 0x2990d(%rip), %rdi     # 0x2f2b2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x13a00
leaq 0x29910(%rip), %rdi     # 0x2f2c6
xorl %eax, %eax
callq 0x13a00
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gengas.c
// Function: printmem
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) {
		fprintf(fd, "(");
		locprint(fd, l->mem.base, 'r');
		if (l->mem.idx) {
			fprintf(fd, ",");
			locprint(fd, l->mem.idx, 'r');
		}
		if (l->mem.scale > 1)
			fprintf(fd, ",%d", l->mem.scale);
		if (l->mem.base)
			fprintf(fd, ")");
	} else if (l->type != Locmeml) {
		die("Only locmeml can have unspecified base reg");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, (%rsi)
jne 0x59eb
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x59fc
leaq 0x29e4e(%rip), %rsi     # 0x2f82d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x59fc
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x59fc
movq %rbx, %rsi
callq 0x4190
cmpq $0x0, 0x28(%r14)
je 0x5a7b
movl $0x28, %edi
movq %rbx, %rsi
callq 0x41f0
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movl $0x72, %edx
callq 0x5a97
cmpq $0x0, 0x30(%r14)
je 0x5a46
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x41f0
movq 0x30(%r14), %rsi
movq %rbx, %rdi
movl $0x72, %edx
callq 0x5a97
movl 0x20(%r14), %edx
cmpl $0x2, %edx
jl 0x5a60
leaq 0x29b6a(%rip), %rsi     # 0x2f5c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x28(%r14)
je 0x5a81
movl $0x29, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41f0
cmpl $0x4, (%r14)
jne 0x5a89
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x29b34(%rip), %rdi     # 0x2f5c4
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/gengas.c
// Function: genstrings
void
genstrings(FILE *fd, Htab *strtab)
{
	void **k;
	Str *s;
	size_t i, nk;

	k = htkeys(strtab, &nk);
	for (i = 0; i < nk; i++) {
		s = k[i];
		fprintf(fd, "%s:\n", (char*)htget(strtab, k[i]));
		writebytes(fd, s->buf, s->len);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x2dedf
cmpq $0x0, (%r12)
je 0x5f38
movq %rax, %r15
leaq 0x29e5d(%rip), %r12     # 0x2fd5b
xorl %ebp, %ebp
movq (%r15,%rbp,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2dd9a
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
movq (%r13), %rdx
movq 0x8(%r13), %rsi
movq %r14, %rdi
callq 0x5f47
incq %rbp
cmpq (%rsp), %rbp
jb 0x5f00
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/gengas.c
// Function: writebytes
static void
writebytes(FILE *fd, char *p, size_t sz)
{
	size_t i;

	for (i = 0; i < sz; i++) {
		if (i % 60 == 0)
			fprintf(fd, "\t.ascii \"");
		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 % 60 == 59 || i == sz - 1)
			fprintf(fd, "\"\n");
	}
}

// Assembly:
testq %rdx, %rdx
je 0x6037
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x1(%rdx), %r13
xorl %r12d, %r12d
movq %r12, %rax
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
mulq %rcx
shrq $0x5, %rdx
imulq $0x3c, %rdx, %rbp
cmpq %r12, %rbp
jne 0x5fa1
movl $0x9, %esi
movl $0x1, %edx
leaq 0x29da3(%rip), %rdi     # 0x2fd3c
movq %r15, %rcx
callq 0x4330
movzbl (%r14,%r12), %eax
cmpl $0x5c, %eax
je 0x5fb0
cmpl $0x22, %eax
jne 0x5fbd
movl $0x5c, %edi
movq %r15, %rsi
callq 0x41f0
callq 0x4390
movq (%rax), %rax
movsbq (%r14,%r12), %rdi
testb $0x40, 0x1(%rax,%rdi,2)
jne 0x5fe8
movzbl %dil, %edx
movq %r15, %rdi
leaq 0x29d67(%rip), %rsi     # 0x2fd46
xorl %eax, %eax
callq 0x4240
jmp 0x5ff0
movq %r15, %rsi
callq 0x41f0
addq $0x3b, %rbp
cmpq %r12, %rbp
setne %al
cmpq %r12, %r13
setne %cl
testb %al, %cl
jne 0x601d
movl $0x2, %esi
movl $0x1, %edx
leaq 0x2a5e7(%rip), %rdi     # 0x305fc
movq %r15, %rcx
callq 0x4330
incq %r12
cmpq %r12, %rbx
jne 0x5f6b
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/gengas.c
// Function: genblob
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);
	if (blob->decl.vis != Visintern)
		fprintf(fd, ".globl %s\n", lbl);
	if (asmsyntax == Gnugaself)
		fprintf(fd, ".section .data.%s,\"aw\",@progbits\n", lbl);
	if (blob->decl.init) {
		fprintf(fd, ".align %zd\n", tyalign(decltype(blob)));
		fprintf(fd, "%s:\n", lbl);

		b = litblob(globls, strtab, blob->decl.init);
		writeblob(fd, b);
		blobfree(b);
	} else {
		fprintf(fd, ".comm %s,%zd\n", lbl, size(blob));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xb, 0x8(%rsi)
jne 0x6135
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2dd9a
movq %rax, %r13
cmpb $0x0, 0x70(%r12)
je 0x607e
leaq 0x29621(%rip), %rsi     # 0x2f692
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x5b143(%rip), %rax     # 0x611c8
cmpl $0x0, (%rax)
jne 0x609e
leaq 0x2960c(%rip), %rsi     # 0x2f69d
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x30(%r12)
je 0x610d
movq %r12, %rdi
callq 0x1e56c
movq %rax, %rdi
callq 0x1282d
leaq 0x29602(%rip), %rsi     # 0x2f6bf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
leaq 0x29c8a(%rip), %rsi     # 0x2fd5b
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4240
movq 0x30(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4af5
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6154
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4a92
movq %r12, %rdi
callq 0x1281a
leaq 0x295af(%rip), %rsi     # 0x2f6cb
movq %rbx, %rdi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4240
leaq 0x29515(%rip), %rdi     # 0x2f651
leaq 0x294ce(%rip), %rsi     # 0x2f611
leaq 0x2951b(%rip), %rcx     # 0x2f665
movl $0x194, %edx            # imm = 0x194
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5a997(%rip), %rax     # 0x611c8
movl (%rax), %eax
cmpl $0x1, %eax
je 0x6856
testl %eax, %eax
jne 0x6948
movq (%r15), %rdx
leaq 0x295e2(%rip), %rsi     # 0x2fe2c
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
jmp 0x686f
leaq 0x295e4(%rip), %rdi     # 0x2fe41
movl $0x1f, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x4330
cmpb $0x0, 0x58(%r15)
je 0x688a
movq (%r15), %rdx
leaq 0x28e12(%rip), %rsi     # 0x2f692
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
movq (%r15), %rdx
leaq 0x294c7(%rip), %rsi     # 0x2fd5b
movq %r14, %rdi
xorl %eax, %eax
callq 0x4240
movq 0x10(%rbx), %rax
cmpq $0x0, 0x20(%rax)
je 0x693e
leaq 0x294a7(%rip), %r15     # 0x2fd5b
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
cmpq $0x0, (%rax,%r12,8)
je 0x692d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x68fa
xorl %r13d, %r13d
movq 0x8(%rax), %rax
movq (%rax,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq 0x10(%rax), %r13
jb 0x68d4
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq $0x0, 0x20(%rax)
je 0x692d
xorl %r13d, %r13d
movq 0x18(%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x5d0d
incq %r13
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq 0x20(%rax), %r13
jb 0x690c
incq %r12
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
jb 0x68b7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x28977(%rip), %rdi     # 0x2f2c6
xorl %eax, %eax
callq 0x13a00
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
testq %r8, %r8
je 0x7144
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %r8, 0x8(%rsp)
movq %r8, %rbx
xorl %ebp, %ebp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2e68c
movq %rbp, %r15
andq $0x7, %r15
jne 0x70aa
movq 0x10(%rsp), %rcx
addq %rbp, %rcx
movq %r13, %rdi
leaq 0x29228(%rip), %rsi     # 0x302c5
movq %r12, %rdx
movq %rax, %r8
xorl %eax, %eax
callq 0x4240
movzbl (%r14,%rbp), %eax
cmpl $0x5c, %eax
je 0x70b9
cmpl $0x22, %eax
jne 0x70c6
movl $0x5c, %edi
movq %r13, %rsi
callq 0x41f0
callq 0x4390
movq (%rax), %rax
movsbq (%r14,%rbp), %rdi
testb $0x40, 0x1(%rax,%rdi,2)
jne 0x70f1
movzbl %dil, %edx
movq %r13, %rdi
leaq 0x28c5e(%rip), %rsi     # 0x2fd46
xorl %eax, %eax
callq 0x4240
jmp 0x70f9
movq %r13, %rsi
callq 0x41f0
cmpl $0x7, %r15d
setne %al
cmpq $0x1, %rbx
setne %cl
testb %al, %cl
jne 0x7124
movl $0x2, %esi
movl $0x1, %edx
leaq 0x294e0(%rip), %rdi     # 0x305fc
movq %r13, %rcx
callq 0x4330
incq %rbp
decq %rbx
jne 0x7075
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29138(%rip), %rdi     # 0x30283
leaq 0x28ffa(%rip), %rsi     # 0x3014c
leaq 0x29132(%rip), %rcx     # 0x3028b
movl $0xc5, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x38, %edi
callq 0x4280
movl %ebp, 0x8(%rax)
movq 0x59670(%rip), %rcx     # 0x60e78
leaq 0x1(%rcx), %rdx
movq %rdx, 0x59665(%rip)     # 0x60e78
movq %rcx, (%rax)
movl (%rbx), %edx
xorl %ecx, %ecx
cmpl $0x28, %edx
ja 0x782c
movl %edx, %esi
addq 0x10(%rbx), %rsi
addl $0x8, %edx
movl %edx, (%rbx)
jmp 0x7838
movq 0x8(%rbx), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rbx)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x784a
movq %rsi, 0x10(%rax,%rcx,8)
incq %rcx
jmp 0x781a
movl %ecx, %ecx
movq %rcx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7857
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7857
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f8a
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: rolop
static Loc*
rolop(Isel *s, Node *n, Node *l, Node *r)
{
	int64_t lv, rv;
	Type *ty;

	ty = tybase(exprtype(n));

	if (!istyunsigned(ty))
		return NULL;
	if (exprop(l) != Obsl && exprop(l) != Obsr)
		return NULL;
	if (exprop(r) != Obsl && exprop(r) != Obsr)
		return NULL;
	if (exprop(r) == exprop(l))
		return NULL;
	if (exprop(l->expr.args[0]) != Ovar)
		return NULL;
	if (exprop(r->expr.args[0]) != Ovar)
		return NULL;
	if (l->expr.args[0]->expr.did != r->expr.args[0]->expr.did)
		return NULL;

	if (exprop(l->expr.args[1]) != Olit)
		return NULL;
	if (l->expr.args[1]->expr.args[0]->type != Nlit)
		return NULL;
	if (l->expr.args[1]->expr.args[0]->lit.littype != Lint)
		return NULL;
	lv = l->expr.args[1]->expr.args[0]->lit.intval;

	if (exprop(r->expr.args[1]) != Olit)
		return NULL;
	if (r->expr.args[1]->expr.args[0]->type != Nlit)
		return NULL;
	if (r->expr.args[1]->expr.args[0]->lit.littype != Lint)
		return NULL;
	rv = r->expr.args[1]->expr.args[0]->lit.intval;

	if (lv + rv != 8*size(n))
		return NULL;

	if (exprop(l) == Obsl)
		return binop(s, Irol, l->expr.args[0], l->expr.args[1]);
	else
		return binop(s, Irol, r->expr.args[0], r->expr.args[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
movq %rax, %rdi
callq 0x23441
testl %eax, %eax
je 0x8e9f
movq %r15, %rdi
callq 0x1d672
cmpl $0xb, %eax
je 0x8d75
movq %r15, %rdi
callq 0x1d672
cmpl $0xc, %eax
jne 0x8e9f
movq %r14, %rdi
callq 0x1d672
cmpl $0xb, %eax
je 0x8d93
movq %r14, %rdi
callq 0x1d672
cmpl $0xc, %eax
jne 0x8e9f
movq %r14, %rdi
callq 0x1d672
movl %eax, %ebp
movq %r15, %rdi
callq 0x1d672
cmpl %eax, %ebp
je 0x8e9f
movq 0x50(%r15), %rax
movq (%rax), %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0x8e9f
movq 0x50(%r14), %rax
movq (%rax), %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0x8e9f
leaq 0x50(%r15), %r13
addq $0x50, %r14
movq (%r13), %rax
movq (%rax), %rcx
movq 0x38(%rcx), %rcx
movq (%r14), %rdx
movq (%rdx), %rdx
cmpq 0x38(%rdx), %rcx
jne 0x8e9f
movq 0x8(%rax), %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x8e9f
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8e9f
cmpl $0x2, 0x18(%rax)
jne 0x8e9f
movq 0x30(%rax), %rbp
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x8e9f
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x8e9f
cmpl $0x2, 0x18(%rax)
jne 0x8e9f
addq 0x30(%rax), %rbp
movq %r12, %rdi
callq 0x1281a
shlq $0x3, %rax
cmpq %rax, %rbp
jne 0x8e9f
movq %r15, %rdi
callq 0x1d672
cmpl $0xb, %eax
cmoveq %r13, %r14
movq (%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movl $0x18, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cc7
xorl %eax, %eax
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/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 %r14
pushq %rbx
subq $0xd8, %rsp
movl %esi, %r10d
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x8f10
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
movl %r10d, %edi
callq 0x77ec
movq %rax, %r14
leaq 0x5829e(%rip), %rax     # 0x611e0
cmpb $0x0, 0x69(%rax)
je 0x8f6b
movq (%r14), %rsi
leaq 0x27b92(%rip), %rdi     # 0x30ae4
xorl %eax, %eax
callq 0x4140
movq 0x3b070(%rip), %rax     # 0x43fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x6813
movq 0x28(%rbx), %rsi
leaq 0x18(%rsi), %rdi
addq $0x20, %rsi
movq %r14, %rdx
callq 0x2d3ff
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %edi
callq 0xaa0e
movq %rax, %rbx
cmpl $0x2, (%r14)
jne 0x8fbd
movl 0x4(%r14), %edi
callq 0xa8d7
movq %r15, %rdi
testl %eax, %eax
je 0x8fcd
movl $0x27, %esi
jmp 0x8fd2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa2fb
jmp 0x8fe2
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl 0x8(%rdi), %eax
cmpl $0xb, %eax
je 0x9003
cmpl $0x8, %eax
jne 0x900d
callq 0x1e5d4
movq %rax, %rdi
jmp 0x9007
movq 0x28(%rdi), %rdi
popq %rax
jmp 0xa374
leaq 0x27b10(%rip), %rdi     # 0x30b24
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: memloc
static Loc *
memloc(Isel *s, Node *e, Mode m)
{
	Node **args;
	Loc *l, *b, *o; /* location, base, offset */
	int scale;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rsi), %r13
movq %rsi, %rdi
callq 0x1d672
cmpl $0x2, %eax
jne 0x90fb
movq (%r13), %rsi
movq %r14, %rdi
callq 0x7857
movq %rax, %r15
movq 0x8(%r13), %r12
movq %r12, %rdi
callq 0x1d672
movb $0x1, %bpl
movl $0x1, 0x4(%rsp)
cmpl $0x4, %eax
jne 0x90b5
movq 0x50(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x90b5
movq 0x50(%r12), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x90b5
cmpl $0x2, 0x18(%rax)
jne 0x90b5
movl 0x30(%rax), %eax
cmpl $0x8, %eax
ja 0x90b5
movl $0x114, %ecx            # imm = 0x114
btl %eax, %ecx
jae 0x90b5
xorl %ebp, %ebp
movl %eax, 0x4(%rsp)
movq 0x8(%r13), %rsi
testb %bpl, %bpl
jne 0x90c5
movq 0x50(%rsi), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x7857
movq %rax, %r12
cmpl $0x2, (%r15)
je 0x90e4
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f8a
movq %rax, %r15
cmpl $0x5, (%r12)
jne 0x9126
movslq 0x4(%rsp), %rdi
imulq 0x10(%r12), %rdi
movq %r15, %rsi
jmp 0x911b
movq %r14, %rdi
movq %r15, %rsi
callq 0x7857
cmpl $0x2, (%rax)
je 0x9116
movq %r14, %rdi
movq %rax, %rsi
callq 0x8f8a
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0xaaa7
jmp 0x9163
cmpl $0x2, (%r15)
je 0x913a
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f8a
movq %rax, %r15
cmpl $0x2, (%r12)
je 0x914f
movq %r14, %rdi
movq %r12, %rsi
callq 0x8f8a
movq %rax, %r12
xorl %edi, %edi
movq %r15, %rsi
movq %r12, %rdx
movl 0x4(%rsp), %ecx
movl %ebx, %r8d
callq 0xaaec
testq %rax, %rax
je 0x9177
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2dd74(%rip), %rdi     # 0x36ef2
leaq 0x278e1(%rip), %rsi     # 0x30a66
leaq 0x279aa(%rip), %rcx     # 0x30b36
movl $0x1d3, %edx            # imm = 0x1D3
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: selcjmp
static void
selcjmp(Isel *s, Node *n, Node **args)
{
	Loc *a, *b;
	Loc *l1, *l2;
	AsmOp cond, jmp;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1d672
movl %eax, %eax
leaq (%rax,%rax,2), %rax
leaq 0x3b091(%rip), %r15     # 0x44270
movl (%r15,%rax,4), %ebp
movq (%r14), %rdi
callq 0x1d672
movq (%r14), %rsi
testl %ebp, %ebp
je 0x924a
movl %ebp, 0x4(%rsp)
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%r15,%rax,4), %ebp
movq 0x50(%rsi), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x7857
movq %rax, %r13
movq (%r14), %rax
cmpq $0x2, 0x40(%rax)
movq %r13, %r12
jne 0x9233
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x7857
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8f8a
movq %rax, %r13
movl %ebp, (%rsp)
movl 0x4(%rsp), %ebp
jmp 0x926f
movq %rbx, %rdi
callq 0x7857
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f8a
movq %rax, %r12
movl $0x36, (%rsp)
movl $0x19, %ebp
movq %rax, %r13
movq 0x8(%r14), %rdi
callq 0xa953
movq %rax, %r15
movq 0x10(%r14), %rdi
callq 0xa953
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
movq %rbx, %rdi
movl (%rsp), %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x8eb0
movq %rbx, %rdi
movl $0x34, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8eb0
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: loc
static Loc *
loc(Isel *s, Node *n)
{
	Node *v;
	Ucon *uc;
	Loc *l;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xb, 0x8(%rsi)
je 0x92fb
movq %rbx, %rdi
callq 0x1d672
cmpl $0x36, %eax
je 0x9337
cmpl $0x35, %eax
je 0x930d
cmpl $0x33, %eax
jne 0x9381
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa71e
movq 0x50(%rbx), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
cmpq $0x7, %rcx
ja 0x93a4
leaq 0x275e4(%rip), %rdx     # 0x3090c
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl 0x30(%rax), %r14d
jmp 0x9352
movq %rbx, %rdi
callq 0x1e5d4
movq 0x50(%rbx), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x233cc
movq 0x8(%rax), %r14
movq %rbx, %rdi
callq 0x8feb
movq %r14, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xabd9
movq 0x30(%rax), %r14
jmp 0x9352
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq 0x30(%rax), %r14
jmp 0x9352
movq %rbx, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x5700e(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rsi
leaq 0x278ee(%rip), %rdi     # 0x30c8b
xorl %eax, %eax
callq 0x13a00
leaq 0x57965(%rip), %rax     # 0x60d10
movq (%rax,%rcx,8), %rsi
leaq 0x278b6(%rip), %rdi     # 0x30c6c
jmp 0x939d
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: blit
static void
blit(Isel *s, Loc *to, Loc *from, size_t dstoff, size_t srcoff, size_t sz, size_t align)
{
	size_t i, modesz;
	Loc *sp, *dp; /* pointers to src, dst */
	Loc *tmp, *src, *dst; /* source memory, dst memory */

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

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

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl $0xe9, %eax
btq %r9, %rax
jb 0x9523
movq %r8, %rbx
testq %r8, %r8
je 0x9514
movq %r9, %r14
movq %rcx, %r15
movq (%rsp), %rax
cmpl $0x2, (%rax)
jne 0x9405
movq 0x8(%rsp), %r12
jmp 0x941a
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x8f8a
movq %rax, (%rsp)
movq 0x10(%rsp), %rsi
cmpl $0x2, (%rsi)
je 0x9431
movq %r12, %rdi
callq 0x8f8a
movq %rax, 0x10(%rsp)
testq %r14, %r14
movl $0x8, %r12d
cmovneq %r14, %r12
movl $0xe9, %eax
btq %r12, %rax
jb 0x9514
xorl %ebp, %ebp
movq %r15, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x27510(%rip), %rax     # 0x30970
movl (%rax,%r12,4), %r14d
movl %r14d, %edi
callq 0xaa0e
leaq (%r12,%rbp), %rcx
cmpq %rbx, %rcx
ja 0x9502
movq %rax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq %rbp, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xaaa7
movq %rax, %r13
leaq (%r15,%rbp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
movl %r14d, %ecx
callq 0xaaa7
movq %rax, %rbx
movq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
movq %r13, %rdx
movq 0x30(%rsp), %r12
movq 0x28(%rsp), %r13
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
movq %r15, %rdi
movl $0x1, %esi
movq %r13, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %rbx
movq 0x20(%rsp), %r15
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
addq %r12, %rbp
leaq (%r12,%rbp), %rax
cmpq %rbx, %rax
jbe 0x9483
shrq %r12
movl $0xe9, %eax
btq %r12, %rax
jae 0x9459
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2777b(%rip), %rdi     # 0x30ca5
leaq 0x27535(%rip), %rsi     # 0x30a66
leaq 0x27788(%rip), %rcx     # 0x30cc0
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: clear
static void
clear(Isel *s, Loc *val, size_t sz, size_t align)
{
	Loc *dp, *zero, *dst; /* source memory, dst memory */
	size_t modesz, i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x2, (%rsi)
jne 0x9561
movq %rsi, (%rsp)
jmp 0x956d
movq %r14, %rdi
callq 0x8f8a
movq %rax, (%rsp)
movl $0x8, %r15d
xorl %r12d, %r12d
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x273e9(%rip), %rax     # 0x30970
movl (%rax,%r15,4), %r13d
movl %r13d, %edi
callq 0xaa0e
movq %rax, %rbp
movq %r14, %rdi
movl $0x13, %esi
movq %rax, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
leaq (%r12,%r15), %rax
cmpq %rbx, %rax
jbe 0x95be
movq 0x8(%rsp), %r14
jmp 0x95fd
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r13d, %ecx
callq 0xaaa7
movq %r14, %rdi
movl $0x1, %esi
movq %rbp, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x8eb0
addq %r15, %r12
leaq (%r15,%r12), %rax
cmpq 0x10(%rsp), %rax
jbe 0x95c7
shrq %r15
movl $0xe9, %eax
btq %r15, %rax
movq 0x10(%rsp), %rbx
jae 0x9580
addq $0x18, %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/isel.c
// Function: movearg
static void
movearg(Isel *s, Loc *dst, PassIn p, Mode m, size_t *nfloats, size_t *nints, size_t *argoff)
{
	Loc *a;
	assert(m != ModeNone);

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

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

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

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

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

// Assembly:
pushq %rbx
callq 0x22c44
movq %rax, %rbx
movl (%rax), %eax
cmpl $0xf, %eax
je 0xa390
cmpl $0x10, %eax
jne 0xa397
movl $0x6, %eax
jmp 0xa3cc
movl $0x5, %eax
jmp 0xa3cc
movq %rbx, %rdi
callq 0x22c1c
movl %eax, %ecx
movl $0x4, %eax
testl %ecx, %ecx
jne 0xa3cc
movq %rbx, %rdi
callq 0x125dd
movq %rax, %rcx
leaq -0x1(%rax), %rdx
xorl %eax, %eax
cmpq $0x7, %rdx
ja 0xa3cc
leaq 0x26950(%rip), %rax     # 0x30d18
movl -0x4(%rax,%rcx,4), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/isel.c
// Function: tymodepart
static Mode tymodepart(Type *t, int is_float, size_t displacement)
{
	assert(isstacktype(t));
	size_t sz = tysize(t);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x22c1c
testl %eax, %eax
je 0xa424
movq %r15, %rdi
callq 0x125dd
movq %rax, %rcx
subq %r14, %rcx
testl %ebx, %ebx
je 0xa404
xorl %eax, %eax
cmpq $0x4, %rcx
setne %al
addl $0x5, %eax
jmp 0xa41e
leaq -0x1(%rcx), %rdx
movl $0x4, %eax
cmpq $0x3, %rdx
ja 0xa41e
leaq 0x2691e(%rip), %rax     # 0x30d38
movl -0x4(%rax,%rcx,4), %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2672d(%rip), %rdi     # 0x30b58
leaq 0x26634(%rip), %rsi     # 0x30a66
leaq 0x2672e(%rip), %rcx     # 0x30b67
movl $0x5c, %edx
callq 0x4180