LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/export.c
// Function: tagreflect
void
tagreflect(Type *t)
{
	size_t i;

	if (hasparams(t) || t->isreflect)
		return;

	t->isreflect = 1;
	for (i = 0; i < t->nsub; i++)
		tagreflect(t->sub[i]);
	switch (t->type) {
	case Tystruct:
		for (i = 0; i < t->nmemb; i++)
			tagreflect(decltype(t->sdecls[i]));
		break;
	case Tyunion:
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype)
				tagreflect(t->udecls[i]->etype);
		break;
	case Tyname:
		for (i = 0; i < t->narg; i++)
			tagreflect(t->arg[i]);
	default:
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x23690
testl %eax, %eax
jne 0x13c25
cmpb $0x0, 0x95(%rbx)
je 0x13c2d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x95(%rbx)
cmpq $0x0, 0x70(%rbx)
je 0x13c54
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x13c0c
incq %r14
cmpq 0x70(%rbx), %r14
jb 0x13c3e
movl (%rbx), %eax
cmpl $0x17, %eax
je 0x13cb8
cmpl $0x18, %eax
je 0x13c87
cmpl $0x1c, %eax
jne 0x13c25
cmpq $0x0, 0x48(%rbx)
je 0x13c25
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x13c0c
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x13c6f
jmp 0x13c25
cmpq $0x0, 0x78(%rbx)
je 0x13c25
xorl %r14d, %r14d
movq 0x88(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x13caa
callq 0x13c0c
incq %r14
cmpq 0x78(%rbx), %r14
jb 0x13c91
jmp 0x13c25
cmpq $0x0, 0x78(%rbx)
je 0x13c25
xorl %r14d, %r14d
movq 0x88(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1e56c
movq %rax, %rdi
callq 0x13c0c
incq %r14
cmpq 0x78(%rbx), %r14
jb 0x13cc6
jmp 0x13c25
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/export.c
// Function: tagtrait
static void
tagtrait(Stab *st, Trait *tr, int ingeneric, int hidelocal)
{
	size_t i;

	if (!tr)
		return;
	if (tr->vis != Visintern)
		return;

	tr->vis = Vishidden;
	if (tr->param)
		tagtype(st, tr->param, ingeneric, hidelocal);
	for (i = 0; i < tr->naux; i++)
		tagtype(st, tr->aux[i], ingeneric, hidelocal);
	for (i = 0; i < tr->nproto; i++)
		tagnode(st, tr->proto[i], ingeneric, hidelocal);
}

// Assembly:
testq %rdi, %rdi
je 0x14636
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0xc(%rdi)
jne 0x1462c
movl %edx, %ebx
movl %esi, %ebp
movl $0x2, 0xc(%r14)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x145e4
movl %ebp, %esi
movl %ebx, %edx
callq 0x142fe
cmpq $0x0, 0x28(%r14)
je 0x14608
xorl %r15d, %r15d
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x142fe
incq %r15
cmpq 0x28(%r14), %r15
jb 0x145ee
cmpq $0x0, 0x38(%r14)
je 0x1462c
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1403a
incq %r15
cmpq 0x38(%r14), %r15
jb 0x14612
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/fold.c
// Function: getintlit
int
getintlit(Node *n, vlong *v)
{
	Node *l;

	if (exprop(n) != Olit)
		return 0;
	l = n->expr.args[0];
	/* It's up to type checking to make sure this is ok */
	if (l->lit.littype == Lint)
		*v = l->lit.intval;
	else if (l->lit.littype == Lchr)
		*v = l->lit.chrval;
	else
		return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d672
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x35, %ecx
jne 0x14674
movq 0x50(%r14), %rcx
movq (%rcx), %rcx
movl 0x18(%rcx), %edx
testl %edx, %edx
je 0x14669
cmpl $0x2, %edx
jne 0x14674
movq 0x30(%rcx), %rax
jmp 0x1466c
movl 0x30(%rcx), %eax
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/fold.c
// Function: idxcmp
int
idxcmp(const void *pa, const void *pb)
{
	Node *a, *b;
	vlong av, bv;

	a = *(Node **)pa;
	b = *(Node **)pb;

	assert(getintlit(a->expr.idx, &av));
	assert(getintlit(b->expr.idx, &bv));

	/* don't trust overflow with int64 */
	if (av < bv)
		return -1;
	else if (av == bv)
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq (%rsi), %rbx
movq 0x48(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x14638
testl %eax, %eax
je 0x146c5
movq 0x48(%rbx), %rdi
movq %rsp, %rsi
callq 0x14638
testl %eax, %eax
je 0x146e4
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
cmpq (%rsp), %rax
setne %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1e788(%rip), %rdi     # 0x32e54
leaq 0x1e79d(%rip), %rsi     # 0x32e70
leaq 0x1e79d(%rip), %rcx     # 0x32e77
movl $0x77, %edx
callq 0x4180
leaq 0x1e7b3(%rip), %rdi     # 0x32e9e
leaq 0x1e77e(%rip), %rsi     # 0x32e70
leaq 0x1e77e(%rip), %rcx     # 0x32e77
movl $0x78, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/fold.c
// Function: val
static Node *
val(Srcloc loc, vlong val, Type *t)
{
	Node *l, *n;

	l = mkint(loc, val);
	n = mkexpr(loc, Olit, l, NULL);
	l->lit.type = t;
	n->expr.type = t;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1e111
movq %rax, %r15
movq %r14, %rdi
movl $0x35, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rbx, 0x20(%r15)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/fold.c
// Function: issmallconst
static int
issmallconst(Node *dcl)
{
	Type *t;

	if (!dcl->decl.isconst)
		return 0;
	if (!dcl->decl.init)
		return 0;
	t = tybase(exprtype(dcl->decl.init));
	if (t->type <= Tyflt64)
		return 1;
	return 0;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x72(%rdi)
je 0x14e04
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x14e04
pushq %rax
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x11, (%rcx)
setb %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/fold.c
// Function: foldcast
static Node *
foldcast(Node *n)
{
	Type *to, *from;
	Node *sub;

	sub = n->expr.args[0];
	to = exprtype(n);
	from = exprtype(sub);

	switch (tybase(to)->type) {
	case Tybool:
	case Tyint8: case Tyint16: case Tyint32: case Tyint64:
	case Tyuint8: case Tyuint16: case Tyuint32: case Tyuint64:
	case Tyint: case Tyuint: case Tychar: case Tybyte:
	case Typtr:
		switch (tybase(from)->type) {
		case Tybool:
		case Tyint8: case Tyint16: case Tyint32: case Tyint64:
		case Tyuint8: case Tyuint16: case Tyuint32: case Tyuint64:
		case Tyint: case Tyuint: case Tychar: case Tybyte:
		case Typtr:
			if (exprop(sub) == Olit || tybase(from)->type == tybase(to)->type) {
				sub->expr.type = to;
				return sub;
			} else {
				return n;
			}
		default:
			return n;
		}
	default:
		return n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq (%rax), %r14
callq 0x1e5d4
movq %rax, %r15
movq %r14, %rdi
callq 0x1e5d4
movq %rax, %r12
movq %r15, %rdi
callq 0x22c44
movl (%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0xd, %ecx
jae 0x14e84
movq %r12, %rdi
callq 0x22c44
movl (%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0xd, %ecx
jae 0x14e8b
movq %r14, %rdi
callq 0x1d672
cmpl $0x35, %eax
je 0x14e71
movq %r12, %rdi
callq 0x22c44
movl (%rax), %ebp
movq %r15, %rdi
callq 0x22c44
cmpl (%rax), %ebp
jne 0x14e78
movq %r15, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x12, %eax
je 0x14e3c
jmp 0x14e78
cmpl $0x12, %eax
je 0x14e4e
jmp 0x14e78
nop
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/gram.c
// Function: yy_symbol_print
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbx
cmpl $0x54, %esi
leaq 0x1e638(%rip), %rax     # 0x353ec
leaq 0x1e637(%rip), %rdx     # 0x353f2
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x2c894(%rip), %rcx     # 0x43660
movq (%rcx,%rax,8), %rcx
leaq 0x1e60d(%rip), %rsi     # 0x353e4
xorl %eax, %eax
callq 0x4240
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: tryconstrain
static int
tryconstrain(Type *base, Trait *tr, int update)
{
	Traitmap *tm;
	Bitset *bs;
	Type *ty;
	size_t i;

	while(1) {
		ty = base;
		tm = traitmap->sub[ty->type];
		while (1) {
			if (ty->type == Typaram)
				if (ty->trneed && bshas(ty->trneed, tr->uid))
					return 1;
			if (ty->type == Tyvar) {
				if (!ty->trneed)
					ty->trneed = mkbs();
				if (update)
					bsput(ty->trneed, tr->uid);
				return 1;
			}
			if (bshas(tm->traits, tr->uid))
				return 1;
			if (tm->name && ty->type == Tyname) {
				bs = htget(tm->name, ty->name);
				if (bs && bshas(bs, tr->uid))
					return 1;
			}
			for (i = 0; i < tm->nfilter; i++) {
				if (tm->filtertr[i]->uid != tr->uid)
					continue;
				if (tymatchrank(tm->filter[i], ty) >= 0)
					return 1;
			}
			if (!ty->sub || ty->nsub != 1)
				break;
			ty = ty->sub[0];
			tm = tm->sub[ty->type];
			if (!tm)
				break;
		}
		if (base->type != Tyname)
			break;
		base = base->sub[0];
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4a13c(%rip), %rax     # 0x617b0
movl (%r14), %ecx
movq 0x8(%rax,%rcx,8), %r12
movq %r14, %r15
movl (%r15), %eax
cmpl $0x1a, %eax
jne 0x176bb
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x176bb
movslq (%rbx), %rdx
movq (%rcx), %rsi
shlq $0x6, %rsi
cmpq %rdx, %rsi
jbe 0x176bb
movq 0x8(%rcx), %rcx
movq %rdx, %rsi
shrq $0x6, %rsi
movq (%rcx,%rsi,8), %rcx
btq %rdx, %rcx
jb 0x177b2
cmpl $0x19, %eax
je 0x177ca
movq (%r12), %rdx
movslq (%rbx), %rcx
movq (%rdx), %rsi
shlq $0x6, %rsi
cmpq %rcx, %rsi
jbe 0x176f0
movq 0x8(%rdx), %rdx
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rdx
btq %rcx, %rdx
jb 0x177b2
cmpl $0x1c, %eax
jne 0x17737
movq 0x100(%r12), %rdi
testq %rdi, %rdi
je 0x17737
movq 0x88(%r15), %rsi
callq 0x2dd9a
testq %rax, %rax
je 0x17737
movslq (%rbx), %rcx
movq (%rax), %rdx
shlq $0x6, %rdx
cmpq %rcx, %rdx
jbe 0x17737
movq 0x8(%rax), %rax
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rax
btq %rcx, %rax
jb 0x177b2
cmpq $0x0, 0x110(%r12)
je 0x1777c
xorl %r13d, %r13d
movq 0x118(%r12), %rax
movq (%rax,%r13,8), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
jne 0x1776f
movq 0x108(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x1729e
testl %eax, %eax
jns 0x177b2
incq %r13
cmpq 0x110(%r12), %r13
jb 0x17745
movq 0x68(%r15), %rax
testq %rax, %rax
je 0x177a0
cmpq $0x1, 0x70(%r15)
jne 0x177a0
movq (%rax), %r15
movl (%r15), %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x1767f
cmpl $0x1c, (%r14)
jne 0x177fb
movq 0x68(%r14), %rax
movq (%rax), %r14
jmp 0x1766d
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x80(%r15)
jne 0x177e0
callq 0x2d63c
movq %rax, 0x80(%r15)
movl $0x1, %r14d
testl %ebp, %ebp
je 0x177b8
movq 0x80(%r15), %rdi
movslq (%rbx), %rsi
callq 0x2d816
jmp 0x177b8
xorl %r14d, %r14d
jmp 0x177b8
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: addbindings
void
addbindings(Node *n, Node **bind, size_t nbind)
{
	size_t i;

	/* order of binding shouldn't matter, so push them into the block
	 * in reverse order. */
	for (i = 0; i < nbind; i++) {
		putdcl(n->block.scope, bind[i]);
		linsert(&n->block.stmts, &n->block.nstmts, 0, bind[i]);
	}
}

// Assembly:
testq %rdx, %rdx
je 0x17857
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %r12
leaq 0x20(%rdi), %r13
xorl %ebp, %ebp
movq 0x18(%r15), %rdi
movq (%r14,%rbp,8), %rsi
callq 0x2071e
movq (%r14,%rbp,8), %rcx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2d46a
incq %rbp
cmpq %rbp, %rbx
jne 0x17823
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/parse/infer.c
// Function: inferstab
static void
inferstab(Stab *s)
{
	void **k;
	size_t n, i;
	Node *dcl;
	Type *t;
	void *se;

	k = htkeys(s->dcl, &n);
	se = curenv();
	for (i = 0; i < n; i++) {
		dcl = htget(s->dcl, k[i]);
		pushenv(dcl->decl.env);
		tf(type(dcl));
		popenv(dcl->decl.env);
		assert(se == curenv());
	}
	free(k);

	k = htkeys(s->ty, &n);
	for (i = 0; i < n; i++) {
		t = gettype(s, k[i]);
		if (!t)
			fatal(k[i], "undefined type %s", namestr(k[i]));
		t = tysearch(t);
		setsuperenv(t->env, curenv());
		pushenv(t->env);
		tyresolve(t);
		popenv(t->env);
		updatetype(s, k[i], t);
	}
	free(k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r14
callq 0x2013d
cmpq $0x0, (%r12)
je 0x187f5
movq %rax, %r15
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
movq (%r14,%r13,8), %rsi
callq 0x2dd9a
movq %rax, %r12
movq 0x38(%rax), %rdi
callq 0x20159
movq %r12, %rdi
callq 0x1b6e6
movq %rax, %rdi
callq 0x196c0
movq 0x38(%r12), %rdi
callq 0x201a4
callq 0x2013d
cmpq %rax, %r15
jne 0x188a2
incq %r13
cmpq (%rsp), %r13
jb 0x187ab
movq %r14, %rdi
callq 0x4040
movq 0x28(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x2dedf
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x1888b
xorl %r12d, %r12d
leaq 0x499b1(%rip), %r13     # 0x621d0
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x205d4
testq %rax, %rax
je 0x188c1
movq (%r13), %rcx
movq %rax, %r15
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x18838
movq 0x60(%r15), %rbp
callq 0x2013d
testq %rbp, %rbp
je 0x18859
movq %rax, (%rbp)
movq 0x60(%r15), %rdi
callq 0x20159
movq %r15, %rdi
callq 0x1ae68
movq 0x60(%r15), %rdi
callq 0x201a4
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x20a41
incq %r12
cmpq (%rsp), %r12
jb 0x1881f
movq %r14, %rdi
callq 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1da6c(%rip), %rdi     # 0x36315
leaq 0x1d9f8(%rip), %rsi     # 0x362a8
leaq 0x1da6d(%rip), %rcx     # 0x36324
movl $0x80a, %edx            # imm = 0x80A
callq 0x4180
movq (%r14,%r12,8), %rbx
movq %rbx, %rdi
callq 0x1e73b
leaq 0x1da67(%rip), %rsi     # 0x3633b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: tf
static Type *
tf(Type *orig)
{
	int isgeneric;
	Type *t, *tt;

	assert(orig != NULL);
	t = tylookup(orig);
	isgeneric = t->type == Tygeneric;
	ingeneric += isgeneric;
	pushenv(orig->env);
	tyresolve(t);
	if ((tt = boundtype(t)) != NULL) {
		t = tt;
		tyresolve(t);
	}
	popenv(orig->env);
	/* If this is an instantiation of a generic type, we want the params to
	 * match the instantiation */
	if (orig->type == Tyunres && t->type == Tygeneric) {
		if (t->ngparam != orig->narg) {
			lfatal(orig->loc, "%s incompatibly specialized with %s, declared on %s:%d",
					tystr(orig), tystr(t), file.files[t->loc.file], t->loc.line);
		}
		pushenv(orig->env);
		t = tysubst(t, orig);
		popenv(orig->env);
	}
	ingeneric -= isgeneric;
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19843
movq %rdi, %rbx
leaq 0x48af6(%rip), %r15     # 0x621d0
movq %rdi, %r14
movq (%r15), %rax
movl 0x4(%r14), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1973c
cmpl $0x1b, (%r14)
jne 0x1973c
callq 0x20037
movq 0x88(%r14), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x1970b
callq 0x2022f
movq 0x88(%r14), %rsi
testq %rax, %rax
je 0x1980d
movq %rax, %rdi
callq 0x205d4
testq %rax, %rax
je 0x19820
cmpq %r14, %rax
je 0x1973c
movq (%r15), %rcx
movl 0x4(%r14), %edx
movq %rax, (%rcx,%rdx,8)
movq (%r15), %rcx
movl 0x4(%r14), %eax
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x19768
movl 0x4(%rdx), %edx
movq (%rcx,%rdx,8), %rdx
testq %rdx, %rdx
je 0x1975c
movq %rdx, (%rcx,%rax,8)
movq (%r15), %rcx
movq (%rcx,%rax,8), %r14
jmp 0x196dd
xorl %ebp, %ebp
cmpl $0x1d, (%r14)
sete %bpl
addl %ebp, 0x48178(%rip)     # 0x618f0
movq 0x60(%rbx), %rdi
callq 0x20159
movq %r14, %rdi
callq 0x1ae68
movq %r14, %rdi
callq 0x21297
testq %rax, %rax
je 0x197a4
movq %rax, %r15
movq %rax, %rdi
callq 0x1ae68
movq %r15, %r14
movq 0x60(%rbx), %rdi
callq 0x201a4
cmpl $0x1b, (%rbx)
jne 0x197f9
cmpl $0x1d, (%r14)
jne 0x197f9
movq 0x38(%r14), %rax
cmpq 0x48(%rbx), %rax
jne 0x19862
movq 0x60(%rbx), %rdi
callq 0x20159
callq 0x1e994
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b84a
movq %rax, %r14
movq %r15, %rdi
callq 0x1e9d5
movq 0x60(%rbx), %rdi
callq 0x201a4
subl %ebp, 0x480f1(%rip)     # 0x618f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsi), %rdx
leaq 0x1cae0(%rip), %rax     # 0x362f8
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x1983c
movq 0x88(%r14), %rbx
movq %r14, %rdi
callq 0x23e44
leaq 0x1cad4(%rip), %rsi     # 0x3630a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
leaq 0x1ca51(%rip), %rdi     # 0x3629b
leaq 0x1ca57(%rip), %rsi     # 0x362a8
leaq 0x1ca58(%rip), %rcx     # 0x362b0
movl $0x289, %edx            # imm = 0x289
callq 0x4180
movq %rbx, %rdi
callq 0x23e44
movq %rax, %r15
movq %r14, %rdi
callq 0x23e44
leaq 0x479fc(%rip), %rcx     # 0x61278
movq 0x8(%rcx), %rcx
movslq 0xc(%r14), %rdx
movq (%rcx,%rdx,8), %r8
movl 0x8(%r14), %r9d
movq 0x8(%rbx), %rdi
leaq 0x1ca2a(%rip), %rsi     # 0x362c1
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x13b8e
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: addtraittab
static void
addtraittab(Traitmap *m, Trait *tr, Type *ty)
{
	Bitset *bs;
	Traitmap *mm;
	size_t i;

	if (!m->sub[ty->type])
		m->sub[ty->type] = mktraitmap();
	mm = m->sub[ty->type];
	switch (ty->type) {
	case Tygeneric:
	case Typaram:
		for (i = 0; i < Ntypes; i++) {
			if (i == Typaram)
				continue;
			if (!m->sub[i])
				m->sub[i] = mktraitmap();
			mm = m->sub[i];
			lappend(&mm->filter, &mm->nfilter, ty);
			lappend(&mm->filtertr, &mm->nfiltertr, tr);
		}
		break;
	case Tyname:
		if (ty->ngparam == 0) {
			bs = htget(mm->name, ty->name);
			if (!bs) {
				bs = mkbs();
				htput(mm->name, ty->name, bs);
			}
			bsput(bs, tr->uid);
		} else {
			lappend(&mm->filter, &m->nfilter, ty);
			lappend(&mm->filtertr, &m->nfiltertr, tr);
		}
		break;
	case Typtr:
	case Tyarray:
		addtraittab(mm, tr, ty->sub[0]);
		break;
	default:
		if (istyprimitive(ty)) {
			bsput(mm->traits, tr->uid);
		} else {
			lappend(&mm->filter, &mm->nfilter, ty);
			lappend(&mm->filtertr, &mm->nfiltertr, tr);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1c163(%rip), %r13     # 0x35a20
movl (%r14), %eax
cmpq $0x0, 0x8(%r15,%rax,8)
jne 0x198d5
callq 0x19a3a
movl (%r14), %ecx
movq %rax, 0x8(%r15,%rcx,8)
movl (%r14), %eax
movq 0x8(%r15,%rax,8), %r12
addl $-0x12, %eax
cmpl $0xb, %eax
ja 0x1999b
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x68(%r14), %rax
movq (%rax), %r14
movq %r12, %r15
jmp 0x198bd
movl $0x1, %r13d
cmpq $0x1b, %r13
je 0x19951
cmpq $0x0, (%r15,%r13,8)
jne 0x1991b
callq 0x19a3a
movq %rax, (%r15,%r13,8)
movq (%r15,%r13,8), %r12
leaq 0x108(%r12), %rdi
leaq 0x110(%r12), %rsi
movq %r14, %rdx
callq 0x2d3ff
leaq 0x118(%r12), %rdi
addq $0x120, %r12            # imm = 0x120
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2d3ff
incq %r13
cmpq $0x20, %r13
jne 0x19905
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x38(%r14)
je 0x199b0
leaq 0x108(%r12), %rdi
leaq 0x110(%r15), %rsi
movq %r14, %rdx
callq 0x2d3ff
addq $0x118, %r12            # imm = 0x118
addq $0x120, %r15            # imm = 0x120
movq %r12, %rdi
movq %r15, %rsi
jmp 0x19a29
movq %r14, %rdi
callq 0x234c5
testl %eax, %eax
je 0x199ff
movq (%r12), %rdi
movslq (%rbx), %rsi
jmp 0x199f1
movq 0x100(%r12), %rdi
movq 0x88(%r14), %rsi
callq 0x2dd9a
movq %rax, %r15
testq %rax, %rax
jne 0x199eb
callq 0x2d63c
movq %rax, %r15
movq 0x100(%r12), %rdi
movq 0x88(%r14), %rsi
movq %rax, %rdx
callq 0x2dbc2
movslq (%rbx), %rsi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2d816
leaq 0x108(%r12), %rdi
leaq 0x110(%r12), %rsi
movq %r14, %rdx
callq 0x2d3ff
leaq 0x118(%r12), %rdi
addq $0x120, %r12            # imm = 0x120
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2d3ff
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: mktraitmap
static Traitmap *
mktraitmap(void)
{
	Traitmap *m;

	m = zalloc(sizeof(Traitmap));
	m->traits = mkbs();
	m->name = mkht(namehash, nameeq);
	return m;
}

// Assembly:
pushq %rbx
movl $0x128, %edi            # imm = 0x128
callq 0x2d348
movq %rax, %rbx
callq 0x2d63c
movq %rax, (%rbx)
leaq 0x4c8a(%rip), %rdi      # 0x1e6e1
leaq 0x4d15(%rip), %rsi      # 0x1e773
callq 0x2db1c
movq %rax, 0x100(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: nodetystr
static char *
nodetystr(Node *n)
{
	Type *t;

	t = NULL;
	if (n->type == Nexpr && exprtype(n) != NULL)
		t = tysearch(exprtype(n));
	else if (n->type == Ndecl && decltype(n) != NULL)
		t = tysearch(decltype(n));

	if (t && tybase(t)->type != Tyvar)
		return tystr(t);
	else
		return strdup("unknown");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, 0x8(%rdi)
jne 0x19e93
movq %rbx, %rdi
callq 0x1e5d4
testq %rax, %rax
je 0x19e93
movq %rbx, %rdi
callq 0x1e5d4
testq %rax, %rax
je 0x19ece
leaq 0x48351(%rip), %rcx     # 0x621d0
movq (%rcx), %rcx
movq %rax, %rbx
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x19e82
jmp 0x19ed0
cmpl $0xb, 0x8(%rbx)
jne 0x19ece
movq %rbx, %rdi
callq 0x1e56c
testq %rax, %rax
je 0x19ece
movq %rbx, %rdi
callq 0x1e56c
testq %rax, %rax
je 0x19ece
leaq 0x48316(%rip), %rcx     # 0x621d0
movq (%rcx), %rcx
movq %rax, %rbx
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x19ebd
jmp 0x19ed0
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x19ee2
movq %rbx, %rdi
callq 0x22c44
cmpl $0x19, (%rax)
jne 0x19eef
leaq 0x1c09a(%rip), %rdi     # 0x35f83
popq %rbx
jmp 0x4340
movq %rbx, %rdi
popq %rbx
jmp 0x23e44
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: ctxstrcall
static void
ctxstrcall(char *buf, size_t sz, Node *n)
{
	char *p, *end, *sep, *t;
	size_t nargs, i;
	Node **args;
	Type *et;

	args = n->expr.args;
	nargs = n->expr.nargs;
	p = buf;
	end = buf + sz;
	sep = "";

	if (exprop(args[0]) == Ovar)
		p += bprintf(p, end - p, "%s(", namestr(args[0]->expr.args[0]));
	else
		p += bprintf(p, end - p, "<e>(");
	for (i = 1; i < nargs; i++) {
		et = tyfix(NULL, exprtype(args[i]), 1);
		if (et != NULL)
			t = tystr(et);
		else
			t = strdup("?");

		if (exprop(args[i]) == Ovar)
			p += bprintf(p, end - p, "%s%s:%s", sep, namestr(args[i]->expr.args[0]), t);
		else
			p += bprintf(p, end - p, "%s<e%zd>:%s", sep, i, t);
		sep = ", ";
		free(t);
	}
	if (exprtype(args[0])->nsub)
		t = tystr(tyfix(NULL, exprtype(args[0])->sub[0], 1));
	else
		t = strdup("unknown");
	p += bprintf(p, end - p, "): %s", t);
	free(t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x40(%rsi), %r13
movq 0x50(%rsi), %rbp
movq (%rbp), %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0x19f4a
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x1e73b
leaq 0x1c055(%rip), %rdx     # 0x35f8b
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e42e
jmp 0x19f60
leaq 0x1c03e(%rip), %rdx     # 0x35f8f
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
xorl %eax, %eax
callq 0x2e42e
movq %rax, %rbx
leaq 0x200(%r15), %r14
addq %r15, %rbx
cmpq $0x2, %r13
jb 0x1a04e
movl $0x1, %r15d
leaq 0x17eb6(%rip), %r12     # 0x31e3a
movq %r13, 0x10(%rsp)
movq (%rbp,%r15,8), %rdi
callq 0x1e5d4
xorl %edi, %edi
movq %rax, %rsi
movl $0x1, %edx
callq 0x1a0c3
testq %rax, %rax
je 0x19fb1
movq %rax, %rdi
callq 0x23e44
jmp 0x19fbd
leaq 0x1bf4a(%rip), %rdi     # 0x35f02
callq 0x4340
movq %rax, 0x8(%rsp)
movq (%rbp,%r15,8), %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0x1a00b
movq %rbp, %r13
movq %r14, %rbp
subq %rbx, %r14
movq (%r13,%r15,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x1e73b
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %r14
movq %r13, %rbp
movq 0x10(%rsp), %r13
leaq 0x1bf91(%rip), %rdx     # 0x35f94
movq %r12, %rcx
movq %rax, %r8
jmp 0x1a021
movq %r14, %rsi
subq %rbx, %rsi
movq %rbx, %rdi
leaq 0x1bf81(%rip), %rdx     # 0x35f9c
movq %r12, %rcx
movq %r15, %r8
movq 0x8(%rsp), %r12
movq %r12, %r9
xorl %eax, %eax
callq 0x2e42e
addq %rax, %rbx
movq %r12, %rdi
callq 0x4040
incq %r15
leaq 0x1bf63(%rip), %r12     # 0x35fa8
cmpq %r15, %r13
jne 0x19f89
movq (%rbp), %rdi
callq 0x1e5d4
cmpq $0x0, 0x70(%rax)
je 0x1a084
movq (%rbp), %rdi
callq 0x1e5d4
movq 0x68(%rax), %rax
movq (%rax), %rsi
xorl %edi, %edi
movl $0x1, %edx
callq 0x1a0c3
movq %rax, %rdi
callq 0x23e44
jmp 0x1a090
leaq 0x1bef8(%rip), %rdi     # 0x35f83
callq 0x4340
movq %rax, %r15
subq %rbx, %r14
leaq 0x1bf0e(%rip), %rdx     # 0x35fab
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e42e
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: traitsfor
static void
traitsfor(Type *base, Bitset *dst)
{
	Traitmap *tm;
	Bitset *bs;
	Type *ty;
	size_t i;

	while(1) {
		ty = base;
		tm = traitmap->sub[ty->type];
		while (1) {
			if (ty->type == Tyvar)
				break;
			if (ty->type == Tyname && ty->ngparam == 0)
				bs = htget(tm->name, ty->name);
			else
				bs = tm->traits;
			if (bs)
				bsunion(dst, bs);
			for (i = 0; i < tm->nfilter; i++) {
				if (tymatchrank(tm->filter[i], ty) >= 0)
					bsput(dst, tm->filtertr[i]->uid);
			}
			if (!tm->sub[ty->type] || ty->nsub != 1)
				break;
			tm = tm->sub[ty->type];
			ty = ty->sub[0];
		}
		if (base->type != Tyname)
			break;
		base = base->sub[0];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x472ec(%rip), %rax     # 0x617b0
movl (%r14), %ecx
movq 0x8(%rax,%rcx,8), %r12
movq %r14, %r15
movl (%r15), %eax
cmpl $0x1c, %eax
je 0x1a4e1
cmpl $0x19, %eax
jne 0x1a4e8
jmp 0x1a57f
cmpq $0x0, 0x38(%r15)
je 0x1a563
movq (%r12), %rsi
testq %rsi, %rsi
je 0x1a4f9
movq %rbx, %rdi
callq 0x2d897
cmpq $0x0, 0x110(%r12)
je 0x1a543
xorl %r13d, %r13d
movq 0x108(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x1729e
testl %eax, %eax
js 0x1a536
movq 0x118(%r12), %rax
movq (%rax,%r13,8), %rax
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d816
incq %r13
cmpq 0x110(%r12), %r13
jb 0x1a507
movl (%r15), %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
je 0x1a57f
cmpq $0x1, 0x70(%r15)
jne 0x1a57f
movq 0x68(%r15), %rax
movq (%rax), %r15
jmp 0x1a4cf
movq 0x100(%r12), %rdi
movq 0x88(%r15), %rsi
callq 0x2dd9a
movq %rax, %rsi
jmp 0x1a4ec
cmpl $0x1c, (%r14)
jne 0x1a591
movq 0x68(%r14), %rax
movq (%rax), %r14
jmp 0x1a4bd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: marksrc
static void
marksrc(Type *t, Srcloc l)
{
	t = tf(t);
	if (t->tid >= nunifysrc) {
		unifysrc = zrealloc(unifysrc, nunifysrc*sizeof(Srcloc), (t->tid + 1)*sizeof(Srcloc));
		nunifysrc = t->tid + 1;
	}
	if (unifysrc[t->tid].line <= 0)
		unifysrc[t->tid] = l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x196c0
movq %rax, %r14
movl 0x4(%rax), %edx
movq 0x46722(%rip), %rsi     # 0x618e0
cmpq %rdx, %rsi
ja 0x1b1ed
movq 0x4671e(%rip), %rdi     # 0x618e8
shlq $0x3, %rsi
incl %edx
shlq $0x3, %rdx
callq 0x2d3a2
movq %rax, 0x46708(%rip)     # 0x618e8
movl 0x4(%r14), %eax
incl %eax
movq %rax, 0x466f3(%rip)     # 0x618e0
movq 0x466f4(%rip), %rax     # 0x618e8
movl 0x4(%r14), %ecx
cmpl $0x0, (%rax,%rcx,8)
jg 0x1b202
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: basetype
static Type *
basetype(Type *a)
{
	Type *t;

	t = a->seqaux;
	while (!t && a->type == Tyname) {
		a = a->sub[0];
		t = a->seqaux;
	}
	if (!t && (a->type == Tyslice || a->type == Tyarray || a->type == Typtr))
		t = a->sub[0];
	if (t)
		t = tf(t);
	return t;
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
jne 0x1b23e
movl (%rdi), %eax
cmpl $0x1c, %eax
jne 0x1b223
movq 0x68(%rdi), %rax
movq (%rax), %rdi
jmp 0x1b20a
cmpl $0x15, %eax
ja 0x1b24e
movl $0x340000, %ecx         # imm = 0x340000
btl %eax, %ecx
movl $0x0, %eax
jae 0x1b23e
movq 0x68(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1b24b
movq %rax, %rdi
jmp 0x196c0
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x1b23e
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: typeerror
static void
typeerror(Type *a, Type *b, Node *ctx, char *msg)
{
	char *t1, *t2, *s1, *s2, *c;

	t1 = tystr(tyfix(NULL, a, 1));
	t2 = tystr(tyfix(NULL, b, 1));
	s1 = srcstr(a);
	s2 = srcstr(b);
	c = ctxstr(ctx);
	if (msg)
		fatal(ctx, "type \"%s\" incompatible with \"%s\" near %s: %s%s%s", t1, t2, c, msg, s1, s2);
	else
		fatal(ctx, "type \"%s\" incompatible with \"%s\" near %s%s%s", t1, t2, c, s1, s2);
	free(t1);
	free(t2);
	free(s1);
	free(s2);
	free(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r12
xorl %edi, %edi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1a0c3
movq %rax, %rdi
callq 0x23e44
movq %rax, %r15
xorl %edi, %edi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x1a0c3
movq %rax, %rdi
callq 0x23e44
movq %rax, %r13
movq %r12, %rdi
callq 0x1b662
movq %rax, %r12
movq %rbp, %rdi
callq 0x1b662
movq %rax, %rbp
movq %r14, %rdi
callq 0x19a6f
testq %rbx, %rbx
jne 0x1b2e2
subq $0x8, %rsp
leaq 0x1ae67(%rip), %rsi     # 0x36132
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %rbp
callq 0x13aa3
leaq 0x1ae18(%rip), %rsi     # 0x36101
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
pushq %rbp
pushq %r12
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: occurs_rec
static int
occurs_rec(Type *sub, Bitset *bs)
{
	size_t i;

	sub = tf(sub);
	if (bshas(bs, sub->tid))
		return 1;
	bsput(bs, sub->tid);
	switch (sub->type) {
	case Typtr:
	case Tyslice:
		break;
	case Tystruct:
		for (i = 0; i < sub->nmemb; i++)
			if (occurs_rec(decltype(sub->sdecls[i]), bs))
				return 1;
		break;
	case Tyunion:
		for (i = 0; i < sub->nmemb; i++) {
			if (!sub->udecls[i]->etype)
				continue;
			if (occurs_rec(sub->udecls[i]->etype, bs))
				return 1;
		}
		break;
	default:
		for (i = 0; i < sub->nsub; i++)
			if (occurs_rec(sub->sub[i], bs))
				return 1;
		break;
	}
	bsdel(bs, sub->tid);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x196c0
movq %rax, %r14
movl 0x4(%rax), %esi
movq (%rbx), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x1b584
movq 0x8(%rbx), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rcx
movl $0x1, %eax
btq %rsi, %rcx
jb 0x1b5b9
movq %rbx, %rdi
callq 0x2d816
movl (%r14), %eax
addl $-0x12, %eax
cmpl $0x6, %eax
ja 0x1b628
leaq 0x1a52a(%rip), %rcx     # 0x35acc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x2d872
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x78(%r14)
je 0x1b5ab
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1b5e9
movq %rbx, %rsi
callq 0x1b54d
testl %eax, %eax
jne 0x1b658
incq %r15
cmpq 0x78(%r14), %r15
jb 0x1b5c9
jmp 0x1b5ab
cmpq $0x0, 0x78(%r14)
je 0x1b5ab
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e56c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b54d
testl %eax, %eax
jne 0x1b658
incq %r15
cmpq 0x78(%r14), %r15
jb 0x1b5fe
jmp 0x1b5ab
cmpq $0x0, 0x70(%r14)
je 0x1b5ab
xorl %r15d, %r15d
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1b54d
testl %eax, %eax
jne 0x1b658
incq %r15
cmpq 0x70(%r14), %r15
jb 0x1b636
jmp 0x1b5ab
movl $0x1, %eax
jmp 0x1b5b9
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movb $0x0, (%rsp)
movl 0x4(%rdi), %eax
cmpq %rax, 0x46264(%rip)     # 0x618e0
jbe 0x1b6d1
movq 0x46263(%rip), %rcx     # 0x618e8
cmpl $0x0, (%rcx,%rax,8)
jle 0x1b6d1
movq (%rcx,%rax,8), %rbx
callq 0x23e44
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d56c
movq %rax, %r15
movq %rbx, %rdi
callq 0x1d580
leaq 0x1aaae(%rip), %rdx     # 0x3615f
movq %rsp, %rdi
movl $0x80, %esi
movq %r14, %rcx
movq %r15, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x4150
movq %r14, %rdi
callq 0x4040
movq %rsp, %rdi
callq 0x4340
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
leal -0x8(%rax), %ecx
cmpl $0x4, %ecx
ja 0x1b7fc
movq %rdi, %rbx
leaq 0x1a3e5(%rip), %rdx     # 0x35ae8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpq $0x0, 0x20(%rbx)
jne 0x1b7e7
movl 0x18(%rbx), %eax
cmpq $0x7, %rax
ja 0x1b7f7
leaq 0x1a3d1(%rip), %rcx     # 0x35afc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
movl $0x3, %esi
jmp 0x1b7b7
movq %rbx, %rdi
callq 0x1e56c
movq %rax, %rdi
jmp 0x1b7eb
movq 0x28(%rbx), %rdi
jmp 0x1b7eb
movq (%rbx), %rdi
movl $0x9, %esi
callq 0x22d38
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x23184
jmp 0x1b7e0
movq (%rbx), %rdi
callq 0x22fd7
movq %rax, %r14
movq 0x4606d(%rip), %rdi     # 0x617f0
jmp 0x1b797
movq (%rbx), %rdi
callq 0x22fd7
movq %rax, %r14
movq 0x460a9(%rip), %rdi     # 0x61840
callq 0x2d680
movq %rax, 0x80(%r14)
jmp 0x1b7e3
movq (%rbx), %rdi
movl $0x1, %esi
jmp 0x1b7b7
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x22d38
jmp 0x1b7e0
movq 0x30(%rbx), %rax
movq 0x28(%rax), %r14
jmp 0x1b7e3
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x22d38
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x231bc
movq %rax, %r14
movq %r14, 0x20(%rbx)
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x196c0
xorl %r14d, %r14d
jmp 0x1b7e3
leaq 0x4549d(%rip), %rcx     # 0x60ca0
movq (%rcx,%rax,8), %rsi
leaq 0x1a9c4(%rip), %rdi     # 0x361d2
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e994
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b84a
movq %rax, %rbx
movq %r15, %rdi
callq 0x1e9d5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x0, 0x38(%rsi)
je 0x1b892
movq %rdx, %r14
xorl %r13d, %r13d
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %r12
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x196c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e938
incq %r13
cmpq 0x38(%rbx), %r13
jb 0x1b866
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1b8a3
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d63c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b958
movl %eax, %ebp
movq %r15, %rdi
callq 0x2d664
testl %ebp, %ebp
je 0x1b8f6
movq 0x60(%rbx), %rdi
callq 0x20159
testq %r14, %r14
je 0x1b8fb
movq 0x45eba(%rip), %rdx     # 0x617a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ea0e
movq %rax, %r14
jmp 0x1b920
movq %rbx, %r14
jmp 0x1b94a
callq 0x1e994
movq %rax, %r15
movq 0x45e96(%rip), %rdx     # 0x617a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ea0e
movq %rax, %r14
movq %r15, %rdi
callq 0x1e9d5
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1b20a
testq %rax, %rax
je 0x1b941
movq %rax, 0x28(%r14)
movq 0x60(%rbx), %rdi
callq 0x201a4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: needfreshenrec
static int
needfreshenrec(Type *t, Bitset *visited)
{
	size_t i;

	t = tysearch(t);
	if (bshas(visited, t->tid))
		return 0;
	bsput(visited, t->tid);
	switch (t->type) {
	case Typaram: return 1;
	case Tygeneric: return 1;
	case Tyname:
		for (i = 0; i < t->narg; i++)
			if (needfreshenrec(t->arg[i], visited))
				return 1;
		return needfreshenrec(t->sub[0], visited);
	case Tystruct:
		for (i = 0; i < t->nmemb; i++)
			if (needfreshenrec(decltype(t->sdecls[i]), visited))
				return 1;
		break;
	case Tyunion:
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype && needfreshenrec(t->udecls[i]->etype, visited))
				return 1;
		break;
	default:
		for (i = 0; i < t->nsub; i++)
			if (needfreshenrec(t->sub[i], visited))
				return 1;
		break;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x46866(%rip), %r15     # 0x621d0
testq %rdi, %rdi
je 0x1b983
movq (%r15), %rax
movq %rdi, %r14
movl 0x4(%rdi), %ecx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
jne 0x1b972
jmp 0x1b986
xorl %r14d, %r14d
movl 0x4(%r14), %esi
movq (%rbx), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x1b9ad
movq 0x8(%rbx), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jb 0x1bac0
movq %rbx, %rdi
callq 0x2d816
movl (%r14), %eax
cmpl $0x1c, %eax
jne 0x1b9f0
cmpq $0x0, 0x48(%r14)
je 0x1b9e4
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1b958
testl %eax, %eax
jne 0x1ba0c
incq %r12
cmpq 0x48(%r14), %r12
jb 0x1b9c7
movq 0x68(%r14), %rax
movq (%rax), %rdi
jmp 0x1b96a
addl $-0x17, %eax
cmpl $0x6, %eax
ja 0x1ba8e
leaq 0x1a119(%rip), %rcx     # 0x35b1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x0, 0x78(%r14)
je 0x1bac0
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1ba4b
movq %rbx, %rsi
callq 0x1b958
testl %eax, %eax
jne 0x1ba0c
incq %r15
xorl %eax, %eax
cmpq 0x78(%r14), %r15
jb 0x1ba2b
jmp 0x1ba11
cmpq $0x0, 0x78(%r14)
je 0x1bac0
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e56c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b958
testl %eax, %eax
jne 0x1ba0c
incq %r15
xorl %eax, %eax
cmpq 0x78(%r14), %r15
jb 0x1ba62
jmp 0x1ba11
cmpq $0x0, 0x70(%r14)
je 0x1bac0
xorl %r15d, %r15d
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1b958
testl %eax, %eax
jne 0x1ba0c
incq %r15
xorl %eax, %eax
cmpq 0x70(%r14), %r15
jb 0x1ba98
jmp 0x1ba11
xorl %eax, %eax
jmp 0x1ba11
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1e56c
movq %rax, %rdi
callq 0x196c0
movq %rax, %r14
cmpl $0x1d, (%rax)
jne 0x1bb54
cmpb $0x0, 0x73(%rbx)
jne 0x1bb54
xorl %edi, %edi
movq %r14, %rsi
callq 0x1b8a3
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e56c
movq %rax, %r15
movl (%r14), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x1bb54
movl (%r15), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x1bb54
movq 0x48(%r14), %rax
cmpq 0x48(%r15), %rax
jne 0x1bbcf
cmpq $0x0, 0x48(%r14)
je 0x1bb54
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rsi
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
callq 0x1a59b
incq %r12
cmpq 0x48(%r14), %r12
jb 0x1bb33
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c85b
cmpq $0x0, 0x30(%rbx)
je 0x1bba7
leaq 0x30(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1bf13
movq %rbx, %rdi
callq 0x1b6e6
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x1b6e6
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a59b
cmpb $0x0, 0x72(%rbx)
je 0x1bba7
movq (%r14), %rax
cmpl $0x0, 0x30(%rax)
je 0x1bbb3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x19a6f
leaq 0x1a7d6(%rip), %rsi     # 0x36398
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
movq %r14, %rdi
callq 0x23e44
movq %rax, %r14
movq %r15, %rdi
callq 0x23e44
movq %rax, %r15
movq %rbx, %rdi
callq 0x19a6f
leaq 0x1a7c3(%rip), %rsi     # 0x363b7
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2d379
movq %rax, %r14
movq %rbx, (%rax)
callq 0x20037
movq %rax, 0x8(%r14)
callq 0x2013d
movq %rax, 0x10(%r14)
leaq 0x45a2b(%rip), %rdi     # 0x61928
leaq 0x45a2c(%rip), %rsi     # 0x61930
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d3ff
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x196c0
movl 0x8(%rbx), %ecx
leal -0x8(%rcx), %edx
cmpl $0x5, %edx
jae 0x1c8a0
movl $0x1b, %esi
btl %edx, %esi
jae 0x1c8a0
movl %edx, %ecx
leaq 0x195fb(%rip), %rdx     # 0x35e80
movq (%rdx,%rcx,8), %rcx
movq %rax, (%rbx,%rcx)
cmpl $0x19, (%rax)
jne 0x1c894
popq %rbx
retq
movq (%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x1b1a5
leaq 0x443f9(%rip), %rax     # 0x60ca0
movq (%rax,%rcx,8), %rsi
leaq 0x19b33(%rip), %rdi     # 0x363e5
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x8, 0x8(%rdi)
jne 0x1c99f
movq %rsi, %r14
movq 0x50(%rbx), %r13
movq %rbx, %rdi
callq 0x1d672
cmpl $0x2a, %eax
jne 0x1c99f
movq (%r13), %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0x1c99f
movq (%r13), %rax
movq 0x50(%rax), %rax
movq (%rax), %r12
movq %r12, %rdi
callq 0x1e73b
movq %rax, %rdi
callq 0x2022f
testq %rax, %rax
je 0x1c99f
movq %rax, %r15
callq 0x20037
movq %rax, %rdi
movq %r12, %rsi
callq 0x2048b
testq %rax, %rax
jne 0x1c99f
movq %r12, %rdi
callq 0x1e73b
movq %rax, %r12
movq 0x8(%r13), %rdi
callq 0x1e73b
movq (%rbx), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e22a
movq %rax, %r12
movq 0x8(%r13), %rsi
movq %r15, %rdi
callq 0x2048b
testq %rax, %rax
je 0x1c9ac
movq %rax, %r15
movq (%rbx), %rdi
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r12
movq 0x48(%rbx), %rax
movq %rax, 0x48(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1cbae
movq %r12, (%r14)
movq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdx
movq 0x20(%r12), %rcx
leaq 0x19adb(%rip), %rsi     # 0x36498
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13aa3