LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: srcstr
static char *
srcstr(Type *ty)
{
	char src[128];
	Srcloc l;
	char *s;

	src[0] = 0;
	if (nunifysrc > ty->tid && unifysrc[ty->tid].line > 0) {
		l = unifysrc[ty->tid];
		s = tystr(ty);
		snprintf(src, sizeof src, "\n\t%s from %s:%d", s, fname(l), lnum(l));
		free(s);
	}
	return strdup(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x90(%rbp)
movq 0x53113(%rip), %rax     # 0x7d400
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x2a3b0
movq 0x53104(%rip), %rax     # 0x7d408
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpl $0x0, (%rax,%rcx,8)
jle 0x2a3b0
movq 0x530ec(%rip), %rax     # 0x7d408
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
callq 0x38a10
movq %rax, -0xa0(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2f090
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2f0b0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %r8
movl %eax, %r9d
movl $0x80, %esi
leaq 0x27d4a(%rip), %rdx     # 0x520e7
movb $0x0, %al
callq 0x6130
movq -0xa0(%rbp), %rdi
callq 0x6040
leaq -0x90(%rbp), %rdi
callq 0x6330
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: type
static Type *
type(Node *n)
{
	Type *t;

	switch (n->type) {
	case Nlit:	t = littype(n);	break;
	case Nexpr:	t = n->expr.type;	break;
	case Ndecl:	t = decltype(n);	break;
	case Nfunc:	t = n->func.type;	break;
	default:
		t = NULL;
		die("untypeable node %s", nodestr[n->type]);
		break;
	};
	return tf(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x2a95f
movq -0x18(%rbp), %rax
leaq 0x2708c(%rip), %rcx     # 0x519a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x2a9a0
movq %rax, -0x10(%rbp)
jmp 0x2a989
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a989
movq -0x8(%rbp), %rdi
callq 0x30260
movq %rax, -0x10(%rbp)
jmp 0x2a989
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2a989
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x51e49(%rip), %rax     # 0x7c7c0
movq (%rax,%rcx,8), %rsi
leaq 0x277d8(%rip), %rdi     # 0x5215a
movb $0x0, %al
callq 0x1df20
movq -0x10(%rbp), %rdi
callq 0x277c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: littype
static Type *
littype(Node *n)
{
	Type *t;

	t = NULL;
	if (!n->lit.type) {
		switch (n->lit.littype) {
		case Lvoid:	t = mktype(n->loc, Tyvoid);	break;
		case Lchr:	t = mktype(n->loc, Tychar);	break;
		case Lbool:	t = mktype(n->loc, Tybool);	break;
		case Lint:	t = mktylike(n->loc, Tyint);	break;
		case Lflt:	t = mktylike(n->loc, Tyflt64);	break;
		case Lstr:	t = mktyslice(n->loc, mktype(n->loc, Tybyte));	break;
		case Llbl:	t = mktyptr(n->loc, mktype(n->loc, Tyvoid));	break;
		case Lfunc:	t = n->lit.fnval->func.type;	break;
		}
		n->lit.type = t;
	}
	return n->lit.type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2aae3
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x2aad7
movq -0x18(%rbp), %rax
leaq 0x26fd9(%rip), %rcx     # 0x519bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x36c10
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x36c10
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x6, %esi
callq 0x2ab00
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x10, %esi
callq 0x2ab00
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x9, %esi
callq 0x36c10
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x373d0
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x37430
movq %rax, -0x10(%rbp)
jmp 0x2aad7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: occurs
static int
occurs(Type *t)
{
	Bitset *bs;
	int r;

	bs = mkbs();
	r = occurs_rec(t, bs);
	bsfree(bs);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x48650
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a100
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48690
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: tysubst
static Type *
tysubst(Type *t, Type *orig)
{
	Tysubst *subst;

	subst = mksubst();
	t = tysubstmap(subst, t, orig);
	substfree(subst);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x30990
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2add0
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a10
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: tysubstmap
static Type *
tysubstmap(Tysubst *subst, Type *t, Type *orig)
{
	size_t i;

	for (i = 0; i < t->ngparam; i++)
		substput(subst, t->gparam[i], tf(orig->arg[i]));
	t = tyfreshen(subst, t);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x2ae49
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x277c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x308e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2adec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ae70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: tyfreshen
static Type *
tyfreshen(Tysubst *subst, Type *orig)
{
	Type *ty, *base;

	if (!needfreshen(orig))
		return orig;
	pushenv(orig->env);
	if (!subst) {
		subst = mksubst();
		ty = tyspecialize(orig, subst, delayed);
		substfree(subst);
	} else {
		ty = tyspecialize(orig, subst, delayed);
	}
	ty->spec = orig->spec;
	ty->nspec = orig->nspec;
	base = basetype(ty);
	if (base)
		ty->seqaux = base;
	popenv(orig->env);
	return ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2af60
cmpl $0x0, %eax
jne 0x2ae9b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2af48
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32f70
cmpq $0x0, -0x10(%rbp)
jne 0x2aedb
callq 0x30990
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x523f9(%rip), %rdx     # 0x7d2c0
callq 0x30a70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a10
jmp 0x2aef3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x523d6(%rip), %rdx     # 0x7d2c0
callq 0x30a70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x297f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2af33
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32fe0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: needfreshen
static int
needfreshen(Type *t)
{
	Bitset *visited;
	int ret;

	visited = mkbs();
	ret = needfreshenrec(t, visited);
	bsfree(visited);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x48650
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2afa0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48690
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: inferdecl
static void
inferdecl(Node *n)
{
	Type *t;

	t = tf(decltype(n));
	if (t->type == Tygeneric && !n->decl.isgeneric) {
		t = tyfreshen(NULL, t);
		unifyparams(n, t, decltype(n));
	}
	settype(n, t);
	if (n->decl.init) {
		inferexpr(&n->decl.init, NULL, NULL);
		unify(n, type(n), type(n->decl.init));
		if (n->decl.isconst && !n->decl.init->expr.isconst)
			fatal(n, "non-const initializer for \"%s\"", ctxstr(n));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x277c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1d, (%rax)
jne 0x2b26e
movq -0x8(%rbp), %rax
cmpb $0x0, 0x73(%rax)
jne 0x2b26e
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2ae70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30260
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x2cd90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ce80
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2b317
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2b810
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a8f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2a8f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x28c00
movq -0x8(%rbp), %rax
movsbl 0x72(%rax), %eax
cmpl $0x0, %eax
je 0x2b315
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2b315
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27be0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x27029(%rip), %rsi     # 0x52337
movb $0x0, %al
callq 0x1dfe0
jmp 0x2b317
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: setsuper
static void
setsuper(Stab *st, Stab *super)
{
	Stab *s;

	/* verify that we don't accidentally create loops */
	for (s = super; s; s = s->super)
		assert(s->super != st);
	st->super = super;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b37c
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x2b34e
jmp 0x2b36d
leaq 0x27041(%rip), %rdi     # 0x52396
leaq 0x26ed4(%rip), %rsi     # 0x52230
movl $0x162, %edx            # imm = 0x162
leaq 0x2703d(%rip), %rcx     # 0x523a5
callq 0x6160
jmp 0x2b36f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b338
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: delayedcheck
static void
delayedcheck(Node *n)
{
	Postcheck *pc;

	pc = xalloc(sizeof(Postcheck));
	pc->node = n;
	pc->stab = curstab();
	pc->env = curenv();
	lappend(&postcheck, &npostcheck, pc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x481b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x32d60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x32f30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
leaq 0x51c58(%rip), %rdi     # 0x7d448
leaq 0x51c59(%rip), %rsi     # 0x7d450
callq 0x48290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: inferfunc
static void
inferfunc(Node *n)
{
	size_t i;
	int sawret;

	sawret = 0;
	for (i = 0; i < n->func.nargs; i++)
		infernode(&n->func.args[i], NULL, NULL);
	infernode(&n->func.body, n->func.type->sub[0], &sawret);
	/* if there's no return stmt in the function, assume void ret */
	if (!sawret)
		unify(n, type(n)->sub[0], mktype(Zloc, Tyvoid));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x2c7d6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x260b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c79b
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax), %rsi
leaq -0x14(%rbp), %rdx
callq 0x260b0
cmpl $0x0, -0x14(%rbp)
jne 0x2c848
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a8f0
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movq -0x1c(%rbp), %rdi
movl $0x1, %esi
callq 0x36c10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x28c00
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: unifyparams
static void
unifyparams(Node *ctx, Type *a, Type *b)
{
	size_t i;

	/* The only types with unifiable params are Tyunres and Tyname.
	 * Tygeneric should always be freshened, and no other types have
	 * parameters attached.
	 *
	 * FIXME: Is it possible to have parameterized typarams? */
	if (a->type != Tyunres && a->type != Tyname)
		return;
	if (b->type != Tyunres && b->type != Tyname)
		return;

	if (a->narg != b->narg)
		fatal(ctx, "mismatched arg list sizes: %s with %s near %s", tystr(a), tystr(b),
				ctxstr(ctx));
	for (i = 0; i < a->narg; i++)
		unify(ctx, a->arg[i], b->arg[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1b, (%rax)
je 0x2cdbb
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
je 0x2cdbb
jmp 0x2ce79
movq -0x18(%rbp), %rax
cmpl $0x1b, (%rax)
je 0x2cdd2
movq -0x18(%rbp), %rax
cmpl $0x1c, (%rax)
je 0x2cdd2
jmp 0x2ce79
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
je 0x2ce2c
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38a10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27be0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0x25531(%rip), %rsi     # 0x52356
movb $0x0, %al
callq 0x1dfe0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x2ce79
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x28c00
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ce34
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: settype
static void
settype(Node *n, Type *t)
{
	t = tf(t);
	switch (n->type) {
	case Nexpr:	n->expr.type = t;	break;
	case Ndecl:	n->decl.type = t;	break;
	case Nlit:	n->lit.type = t;	break;
	case Nfunc:	n->func.type = t;	break;
	default: die("untypable node %s", nodestr[n->type]); break;
	}
	if (t->type != Tyvar)
		marksrc(t, n->loc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x277c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x2cefe
movq -0x18(%rbp), %rax
leaq 0x24d9f(%rip), %rcx     # 0x51c5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2cf20
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x2cf20
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2cf20
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x2cf20
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x4f8b2(%rip), %rax     # 0x7c7c0
movq (%rax,%rcx,8), %rsi
leaq 0x2546b(%rip), %rdi     # 0x52384
movb $0x0, %al
callq 0x1df20
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
je 0x2cf39
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x29750
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: checkns
static Node *
checkns(Node *n, Node **ret)
{
	Node *var, *name, *nsname;
	Node **args;
	Stab *stab;
	Node *s;

	/* check that this is a namespaced declaration */
	args = n->expr.args;
	if (n->type != Nexpr || exprop(n) != Omemb || exprop(args[0]) != Ovar)
		return n;
	name = args[0]->expr.args[0];
	stab = getns(namestr(name));
	if (!stab || getdcl(curstab(), name))
		return n;

	/* substitute the namespaced name */
	nsname = mknsname(n->loc, namestr(name), namestr(args[1]));
	s = getdcl(stab, args[1]);
	if (!s)
		fatal(n, "undeclared var %s.%s", nsname->name.ns, nsname->name.name);
	var = mkexpr(n->loc, Ovar, nsname, NULL);
	var->expr.idx = n->expr.idx;
	initvar(var, s);
	*ret = var;
	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x2cf85
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x2a, %eax
jne 0x2cf85
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x2f210
cmpl $0x33, %eax
je 0x2cf92
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d0aa
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30600
movq %rax, %rdi
callq 0x330b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2cfd7
callq 0x32d60
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x334b0
cmpq $0x0, %rax
je 0x2cfe4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d0aa
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30600
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30600
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x2fec0
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x334b0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x2d05b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x253e3(%rip), %rsi     # 0x52437
movb $0x0, %al
callq 0x1dfe0
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2d210
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: inferucon
static void
inferucon(Node *n, int *isconst)
{
	Ucon *uc;
	Type *t;

	*isconst = 1;
	uc = uconresolve(n);
	/* Hackety hack hack.
	 * the types in a generic union may be bound from the tyname that
	 * defined it, which is not accessible here.
	 *
	 * To make it compile, for now, we just bind the types in here.
	 */
	t = uc->utype;
	if (t->type != Tyunion)
		t = t->sub[0];
	assert(t->type == Tyunion);
	t = tysubst(tf(t), t);
	uc = tybase(t)->udecls[uc->id];
	if (uc->etype) {
		inferexpr(&n->expr.args[1], NULL, NULL);
		unify(n, uc->etype, type(n->expr.args[1]));
		*isconst = n->expr.args[1]->expr.isconst;
	}
	settype(n, delayeducon(uc->utype));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2d4d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x18, (%rax)
je 0x2d10b
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x2d116
jmp 0x2d135
leaq 0x2536d(%rip), %rdi     # 0x5248a
leaq 0x2510c(%rip), %rsi     # 0x52230
movl $0x5e8, %edx            # imm = 0x5E8
leaq 0x2536d(%rip), %rcx     # 0x5249d
callq 0x6160
movq -0x20(%rbp), %rdi
callq 0x277c0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2ad80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x36a30
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2d1db
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2b810
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2a8f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x28c00
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2d610
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2ce80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: addspecialization
static void
addspecialization(Node *n, Stab *stab)
{
	Node *dcl;

	dcl = decls[n->expr.did];
	lappend(&specializationscope, &nspecializationscope, stab);
	lappend(&specializations, &nspecializations, n);
	lappend(&genericdecls, &ngenericdecls, dcl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x50021(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x4ff93(%rip), %rdi     # 0x7d418
leaq 0x4ff94(%rip), %rsi     # 0x7d420
callq 0x48290
movq -0x8(%rbp), %rdx
leaq 0x4ff8c(%rip), %rdi     # 0x7d428
leaq 0x4ff8d(%rip), %rsi     # 0x7d430
callq 0x48290
movq -0x18(%rbp), %rdx
leaq 0x4ff85(%rip), %rdi     # 0x7d438
leaq 0x4ff86(%rip), %rsi     # 0x7d440
callq 0x48290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: uconresolve
static Ucon *
uconresolve(Node *n)
{
	Ucon *uc;
	Node **args;
	Stab *ns;

	args = n->expr.args;
	ns = curstab();
	if (args[0]->name.ns)
		ns = getns(args[0]->name.ns);
	if (!ns)
		fatal(n, "no namespace %s\n", args[0]->name.ns);
	uc = getucon(ns, args[0]);
	if (!uc)
		fatal(n, "no union constructor `%s", ctxstr(args[0]));
	if (!uc->etype && n->expr.nargs > 1)
		fatal(n, "nullary union constructor `%s passed arg ", ctxstr(args[0]));
	else if (uc->etype && n->expr.nargs != 2)
		fatal(n, "union constructor `%s needs arg ", ctxstr(args[0]));
	return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x32d60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2d513
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x330b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2d537
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
leaq 0x24f8b(%rip), %rsi     # 0x524bb
movb $0x0, %al
callq 0x1dfe0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x33810
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d57b
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x27be0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x24f58(%rip), %rsi     # 0x524cc
movb $0x0, %al
callq 0x1dfe0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x2d5ba
movq -0x8(%rbp), %rax
cmpq $0x1, 0x40(%rax)
jbe 0x2d5ba
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x27be0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x24f32(%rip), %rsi     # 0x524e5
movb $0x0, %al
callq 0x1dfe0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2d5f9
movq -0x8(%rbp), %rax
cmpq $0x2, 0x40(%rax)
je 0x2d5f9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x27be0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x24f1d(%rip), %rsi     # 0x5250f
movb $0x0, %al
callq 0x1dfe0
jmp 0x2d5fb
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: delayeducon
static Type *
delayeducon(Type *fallback)
{
	Type *t;

	if (fallback->type != Tyunion)
		return fallback;
	t = mktylike(fallback->loc, fallback->type);
	htput(delayed, t, fallback);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
je 0x2d62f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d662
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
movq 0x8(%rax), %rdi
callq 0x2ab00
movq %rax, -0x18(%rbp)
movq 0x4fc73(%rip), %rdi     # 0x7d2c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x49100
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: infersub
static void
infersub(Node *n, Type *ret, int *sawret, int *exprconst)
{
	Node **args;
	size_t i, nargs;
	int isconst;

	/* Ovar has no subexpressions */
	if (exprop(n) == Ovar)
		return;
	args = n->expr.args;
	nargs = n->expr.nargs;
	isconst = 1;
	for (i = 0; i < nargs; i++) {
		/* Nlit, Nvar, etc should not be inferred as exprs */
		if (args[i]->type == Nexpr) {
			/* Omemb can sometimes resolve to a namespace. We have to check
			 * this. Icky. */
			checkns(args[i], &args[i]);
			inferexpr(&args[i], ret, sawret);
			isconst = isconst && args[i]->expr.isconst;
		}
	}
	if (opispure[exprop(n)])
		n->expr.isconst = isconst;
	*exprconst = n->expr.isconst;
}

// 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 -0x8(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
jne 0x2d69b
jmp 0x2d78e
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x2d75d
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
jne 0x2d74a
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2cf40
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2b810
xorl %eax, %eax
cmpl $0x0, -0x3c(%rbp)
movb %al, -0x3d(%rbp)
je 0x2d73f
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x30(%rax)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2d74c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2d6c2
movq -0x8(%rbp), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x4ed4f(%rip), %rax     # 0x7c4c0
cmpl $0x0, (%rax,%rcx,4)
je 0x2d781
movl -0x3c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: infertuple
static void
infertuple(Node *n, int *isconst)
{
	Type **types;
	size_t i;

	*isconst = 1;
	types = xalloc(sizeof(Type *) * n->expr.nargs);
	for (i = 0; i < n->expr.nargs; i++) {
		infernode(&n->expr.args[i], NULL, NULL);
		n->expr.isconst = n->expr.isconst && n->expr.args[i]->expr.isconst;
		types[i] = type(n->expr.args[i]);
	}
	*isconst = n->expr.isconst;
	settype(n, mktytuple(n->loc, types, n->expr.nargs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
shlq $0x3, %rdi
callq 0x481b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2dab5
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x260b0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x30(%rcx)
movb %al, -0x21(%rbp)
je 0x2da71
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x30(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a8f0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2da17
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq (%rax), %rdi
callq 0x37490
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2ce80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: inferstruct
static void
inferstruct(Node *n, int *isconst)
{
	size_t i;

	*isconst = 1;
	/* we want to check outer nodes before inner nodes when unifying nested structs */
	delayedcheck(n);
	for (i = 0; i < n->expr.nargs; i++) {
		infernode(&n->expr.args[i], NULL, NULL);
		if (!n->expr.args[i]->expr.isconst)
			*isconst = 0;
	}
	settype(n, mktyvar(n->loc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2b7a0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2db88
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x260b0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2db78
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2db7a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2db2b
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x370c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2ce80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: inferarray
static void
inferarray(Node *n, int *isconst)
{
	size_t i;
	Type *t;
	Node *len;

	*isconst = 1;
	len = mkintlit(n->loc, arraysize(n));
	t = mktyarray(n->loc, mktyvar(n->loc), len);
	for (i = 0; i < n->expr.nargs; i++) {
		infernode(&n->expr.args[i], NULL, NULL);
		unify(n, t->sub[0], type(n->expr.args[i]));
		if (!n->expr.args[i]->expr.isconst)
			*isconst = 0;
	}
	settype(n, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2dce0
movq %rax, %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x2f3c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x370c0
movq %rax, %rsi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax), %rdi
callq 0x37350
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2dcc1
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x260b0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a8f0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x28c00
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2dcae
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2dcb0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2dc21
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2ce80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: arraysize
static int64_t
arraysize(Node *n)
{
	int64_t sz, off, i;
	Node **args, *idx;

	sz = 0;
	args = n->expr.args;
	for (i = 0; i < n->expr.nargs; i++) {
		if (args[i]->expr.idx) {
			args[i]->expr.idx = fold(args[i]->expr.idx, 1);
			idx = args[i]->expr.idx;
			if (exprop(idx) != Olit)
				fatal(idx, "nonconstant array initializer index near %s\n",
					ctxstr(idx));
			if (idx->expr.args[0]->lit.littype == Lchr)
				off = idx->expr.args[0]->lit.chrval;
			else if (idx->expr.args[0]->lit.littype == Lint)
				off = idx->expr.args[0]->lit.intval;
			else
				fatal(idx, "noninteger array initializer index near %s\n",
					ctxstr(idx));
			if (off >= sz)
				sz = off + 1;
		} else {
			sz++;
		}
	}
	return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2de50
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x48(%rax)
je 0x2de31
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rdi
movl $0x1, %esi
callq 0x1f390
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x2dda6
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x27be0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x248d4(%rip), %rsi     # 0x52673
movb $0x0, %al
callq 0x1dfe0
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
jne 0x2ddcb
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0x2de19
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0x2ddf1
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2de17
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x27be0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x24890(%rip), %rsi     # 0x526a0
movb $0x0, %al
callq 0x1dfe0
jmp 0x2de19
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jl 0x2de2f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2de3d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2de3f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2dd08
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: postcheckpass
static void
postcheckpass(Postcheck ***post, size_t *npost)
{
	size_t i;
	Node *n;

	for (i = 0; i < npostcheck; i++) {
		n = postcheck[i]->node;
		pushstab(postcheck[i]->stab);
		pushenv(postcheck[i]->env);
		if (n->type == Nexpr) {
			switch (exprop(n)) {
			case Otupmemb:
			case Omemb:	infercompn(n, post, npost);	break;
			case Ocast:	checkcast(n, post, npost);	break;
			case Ostruct:	checkstruct(n, post, npost);	break;
			case Ovar:	checkvar(n, post, npost);	break;
			default:
				die("should not see %s in postcheck\n", opstr[exprop(n)]);
				break;
			}
		} else if (n->type == Niterstmt) {
			fixiter(n, type(n->iterstmt.seq), type(n->iterstmt.elt));
		}
		popenv(postcheck[i]->env);
		popstab();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x4f5cd(%rip), %rax     # 0x7d450
jae 0x2dfec
movq 0x4f5b8(%rip), %rax     # 0x7d448
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x4f5a2(%rip), %rax     # 0x7d448
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x32db0
movq 0x4f58a(%rip), %rax     # 0x7d448
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x32f70
movq -0x20(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x2df7c
movq -0x20(%rbp), %rdi
callq 0x2f210
addl $-0x2a, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xe, %eax
ja 0x2df54
movq -0x28(%rbp), %rax
leaq 0x23d71(%rip), %rcx     # 0x51c70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e000
jmp 0x2df7a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e4d0
jmp 0x2df7a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e4f0
jmp 0x2df7a
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2e6e0
jmp 0x2df7a
movq -0x20(%rbp), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x4df58(%rip), %rax     # 0x7bec0
movq (%rax,%rcx,8), %rsi
leaq 0x247fa(%rip), %rdi     # 0x5276d
movb $0x0, %al
callq 0x1df20
jmp 0x2dfbe
movq -0x20(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x2dfbc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2a8f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2a8f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2e7d0
jmp 0x2dfbe
movq 0x4f483(%rip), %rax     # 0x7d448
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x32fe0
callq 0x32e20
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2de78
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: checkvar
static void
checkvar(Node *n, Postcheck ***post, size_t *npost)
{
	Node *proto, *dcl;
	Type *ty;

	proto = decls[n->expr.did];
	ty = NULL;
	dcl = NULL;
	pushenv(proto->decl.env);
	if (n->expr.param)
		dcl = htget(proto->decl.impls, tf(n->expr.param));
	if (dcl)
		ty = dcl->decl.type;
	if (!ty)
		ty = tyfreshen(NULL, type(proto));
	unify(n, type(n), ty);
	popenv(proto->decl.env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4ed8d(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32f70
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2e75f
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x277c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x49490
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e772
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2e792
movq -0x20(%rbp), %rdi
callq 0x2a8f0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2ae70
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a8f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0x28c00
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32fe0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: fixiter
static void
fixiter(Node *n, Type *ty, Type *base)
{
	size_t i, bestidx;
	int r, bestrank;
	Type *b, *t, *orig;
	Tysubst *ts;
	Node *impl;

	ty = tysearch(ty);
	b = ty->seqaux;
	if (!b)
		return;
	bestrank = -1;
	bestidx = 0;
	for (i = 0; i < nimpltab; i++) {
		if (impltab[i]->impl.trait != traittab[Tciter])
			continue;
		r = tymatchrank(impltab[i]->impl.type, ty);
		if (r > bestrank) {
			bestrank = r;
			bestidx = i;
		}
	}
	if (bestrank >= 0) {
		impl = impltab[bestidx];
		orig = impl->impl.type;
		t = tf(impl->impl.aux[0]);
		ts = mksubst();
		for (i = 0; i < ty->narg; i++)
			substput(ts, tf(orig->arg[i]), ty->arg[i]);
		t = tyfreshen(ts, t);
		substfree(ts);
		unify(n, t, base);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25450
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2e809
jmp 0x2e971
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x4f4fd(%rip), %rcx     # 0x7dd28
cmpq (%rcx), %rax
jae 0x2e8a0
leaq 0x4f4e9(%rip), %rax     # 0x7dd20
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
leaq 0x4f4c3(%rip), %rcx     # 0x7dd10
movq (%rcx), %rcx
cmpq 0x30(%rcx), %rax
je 0x2e858
jmp 0x2e892
leaq 0x4f4c1(%rip), %rax     # 0x7dd20
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x254b0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x2e890
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2e892
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e820
cmpl $0x0, -0x30(%rbp)
jl 0x2e971
leaq 0x4f46f(%rip), %rax     # 0x7dd20
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x277c0
movq %rax, -0x40(%rbp)
callq 0x30990
movq %rax, -0x50(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x2e946
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x277c0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x308e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e8f1
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2ae70
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30a10
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28c00
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: maincompatible
static int
maincompatible(Type *t)
{
	if (t->nsub > 2)
		return 0;
	if (tybase(t->sub[0])->type != Tyvoid)
		return 0;
	if (t->nsub == 2) {
		t = tybase(t->sub[1]);
		if (t->type != Tyslice)
			return 0;
		t = tybase(t->sub[0]);
		if (t->type != Tyslice)
			return 0;
		t = tybase(t->sub[0]);
		if (t->type != Tybyte)
			return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0x70(%rax)
jbe 0x2e9a3
movl $0x0, -0x4(%rbp)
jmp 0x2ea4b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x36a30
cmpl $0x1, (%rax)
je 0x2e9c4
movl $0x0, -0x4(%rbp)
jmp 0x2ea4b
movq -0x10(%rbp), %rax
cmpq $0x2, 0x70(%rax)
jne 0x2ea44
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
je 0x2e9f6
movl $0x0, -0x4(%rbp)
jmp 0x2ea4b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
je 0x2ea1c
movl $0x0, -0x4(%rbp)
jmp 0x2ea4b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
je 0x2ea42
movl $0x0, -0x4(%rbp)
jmp 0x2ea4b
jmp 0x2ea44
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: initcompatible
static int
initcompatible(Type *t)
{
	if (t->type != Tyfunc)
		return 0;
	if (t->nsub != 1)
		return 0;
	if (tybase(t->sub[0])->type != Tyvoid)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, (%rax)
je 0x2ea7e
movl $0x0, -0x4(%rbp)
jmp 0x2eab7
movq -0x10(%rbp), %rax
cmpq $0x1, 0x70(%rax)
je 0x2ea92
movl $0x0, -0x4(%rbp)
jmp 0x2eab7
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x36a30
cmpl $0x1, (%rax)
je 0x2eab0
movl $0x0, -0x4(%rbp)
jmp 0x2eab7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq