LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/export.c
// Function: isexportval
int
isexportval(Node *n)
{
	if (n->decl.isgeneric && !n->decl.trait)
		return 1;
	/* we want to inline small values, which means we need to export them */
	if (istyprimitive(n->decl.type))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x73(%rax), %eax
cmpl $0x0, %eax
je 0x1e36d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x1e36d
movl $0x1, -0x4(%rbp)
jmp 0x1e38f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x37980
cmpl $0x0, %eax
je 0x1e388
movl $0x1, -0x4(%rbp)
jmp 0x1e38f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f162
jmp 0x1f224
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1f171
jmp 0x1f224
movq -0x10(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f19e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x1ede0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x1f1e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x1ede0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f1a6
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x1f224
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x1e8d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f1e9
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x1f257
movl $0x0, -0x4(%rbp)
jmp 0x1f2af
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x1f281
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f2a8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1f29d
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f2a6
movl $0x0, -0x4(%rbp)
jmp 0x1f2af
jmp 0x1f2a8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1f230
cmpl $0x0, %eax
je 0x1f2fe
jmp 0x1f31d
leaq 0x2fa13(%rip), %rdi     # 0x4ed18
leaq 0x2fa28(%rip), %rsi     # 0x4ed34
movl $0x77, %edx
leaq 0x2fa23(%rip), %rcx     # 0x4ed3b
callq 0x6160
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1f230
cmpl $0x0, %eax
je 0x1f335
jmp 0x1f354
leaq 0x2fa26(%rip), %rdi     # 0x4ed62
leaq 0x2f9f1(%rip), %rsi     # 0x4ed34
movl $0x78, %edx
leaq 0x2f9ec(%rip), %rcx     # 0x4ed3b
callq 0x6160
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jge 0x1f367
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f381
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x1f37a
movl $0x0, -0x4(%rbp)
jmp 0x1f381
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x2fdb0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x72(%rax)
jne 0x1fe4f
movl $0x0, -0x4(%rbp)
jmp 0x1fe95
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1fe63
movl $0x0, -0x4(%rbp)
jmp 0x1fe95
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
ja 0x1fe8e
movl $0x1, -0x4(%rbp)
jmp 0x1fe95
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30340
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x2, %eax
subl $0xd, %eax
jb 0x1ff47
jmp 0x1ff3d
movl -0x2c(%rbp), %eax
subl $0x12, %eax
jne 0x1ffc2
jmp 0x1ff47
movq -0x20(%rbp), %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addl $-0x2, %eax
subl $0xd, %eax
jb 0x1ff69
jmp 0x1ff5f
movl -0x30(%rbp), %eax
subl $0x12, %eax
jne 0x1ffb8
jmp 0x1ff69
movq -0x28(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x1ff98
movq -0x20(%rbp), %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36a30
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jne 0x1ffae
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ffca
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ffca
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ffca
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/gram.c
// Function: yy_stack_print
static void
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
{
  YYFPRINTF (stderr, "Stack now");
  for (; yybottom <= yytop; yybottom++)
    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }
  YYFPRINTF (stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3a819(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq 0x2cab9(%rip), %rsi     # 0x5129a
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x24825
movq -0x8(%rbp), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x3a7ed(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x27f00(%rip), %rsi     # 0x4c710
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x247e8
movq 0x3a7c4(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq 0x29380(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edx
leaq 0x2ca3d(%rip), %rax     # 0x512b2
leaq 0x2ca30(%rip), %rcx     # 0x512ac
cmpl $0x54, %edx
cmovlq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x25400
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x2ca03(%rip), %rsi     # 0x512a4
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x25420
movq -0x8(%rbp), %rdi
leaq 0x2eb24(%rip), %rsi     # 0x533e7
movb $0x0, %al
callq 0x6230
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/gram.c
// Function: yy_reduce_print
static void
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
                 int yyrule)
{
  int yylno = yyrline[yyrule];
  int yynrhs = yyr2[yyrule];
  int yyi;
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
             yyrule - 1, yylno);
  /* The symbols being reduced.  */
  for (yyi = 0; yyi < yynrhs; yyi++)
    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr,
                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
                       &yyvsp[(yyi + 1) - (yynrhs)]);
      YYFPRINTF (stderr, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x2c612(%rip), %rax     # 0x50f00
movswl (%rax,%rcx,2), %eax
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x2c0a0(%rip), %rax     # 0x509a0
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq 0x3a6e2(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movl -0x18(%rbp), %ecx
leaq 0x2ce76(%rip), %rsi     # 0x51797
movb $0x0, %al
callq 0x6230
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x249c6
movq 0x3a6ae(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movl -0x20(%rbp), %edx
addl $0x1, %edx
leaq 0x2ce6b(%rip), %rsi     # 0x517bd
movb $0x0, %al
callq 0x6230
movq 0x3a690(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
movslq %eax, %rcx
leaq 0x2c3bf(%rip), %rax     # 0x50d40
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rdx
movl -0x20(%rbp), %eax
addl $0x1, %eax
subl -0x1c(%rbp), %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdx
callq 0x24850
movq 0x3a649(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq 0x29205(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2492f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: tysearch
Type *
tysearch(Type *t)
{
	if (!t)
		return t;
	while (tytab[t->tid])
		t = tytab[t->tid];
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25469
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x254a6
jmp 0x2546b
leaq 0x58876(%rip), %rax     # 0x7dce8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2549e
leaq 0x5885e(%rip), %rax     # 0x7dce8
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x2546b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x25caa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33970
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x48370
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x25c4c
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: infer
void
infer(void)
{
	size_t i;

	delayed = mkht(tyhash, tyeq);
	initimpl();

	/* do the inference */
	pushstab(file.globls);
	inferstab(file.globls);
	for (i = 0; i < file.nstmts; i++)
		infernode(&file.stmts[i], NULL, 0);
	popstab();
	postinfer();

	/* and replace type vars with actual types */
	pushstab(file.globls);
	stabsub(file.globls);
	for (i = 0; i < file.nstmts; i++)
		typesub(file.stmts[i], 0);
	popstab();

	specialize();
	verify();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x12d91(%rip), %rdi     # 0x38a50
leaq 0x1369a(%rip), %rsi     # 0x39360
callq 0x48fe0
movq %rax, 0x575ee(%rip)     # 0x7d2c0
callq 0x25dd0
leaq 0x570ba(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x32db0
leaq 0x570a7(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x25ec0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x57088(%rip), %rcx     # 0x7cd98
cmpq 0x48(%rcx), %rax
jae 0x25d46
leaq 0x5707b(%rip), %rax     # 0x7cd98
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x260b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x25d05
callq 0x32e20
callq 0x266d0
leaq 0x57041(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x32db0
leaq 0x5702e(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x26720
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x5700f(%rip), %rcx     # 0x7cd98
cmpq 0x48(%rcx), %rax
jae 0x25db7
leaq 0x57002(%rip), %rax     # 0x7cd98
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x268f0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x25d7e
callq 0x32e20
callq 0x26f20
callq 0x272a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: initimpl
static void
initimpl(void)
{
	size_t i;
	Node *impl;
	Trait *tr;
	Type *ty;

	pushstab(file.globls);
	traitmap = zalloc(sizeof(Traitmap));
	builtintraits();
	for (i = 0; i < nimpltab; i++) {
		impl = impltab[i];
		tr = findtrait(impl);

		pushenv(impl->impl.env);
		ty = tf(impl->impl.type);
		addtraittab(traitmap, tr, ty);
		if (tr->uid == Tciter)
			ty->seqaux = tf(impl->impl.aux[0]);
		popenv(impl->impl.env);
	}
	popstab();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x56fb9(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x32db0
movl $0x128, %edi            # imm = 0x128
callq 0x48160
movq %rax, 0x574d4(%rip)     # 0x7d2d0
callq 0x274b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x57f14(%rip), %rcx     # 0x7dd28
cmpq (%rcx), %rax
jae 0x25eb4
leaq 0x57efc(%rip), %rax     # 0x7dd20
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x276b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32f70
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x277c0
movq %rax, -0x20(%rbp)
movq 0x5746b(%rip), %rdi     # 0x7d2d0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x27940
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x25e96
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x277c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32fe0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x25e09
callq 0x32e20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x10(%rbp)
callq 0x32f30
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x25f95
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32f70
movq -0x28(%rbp), %rdi
callq 0x2a8f0
movq %rax, %rdi
callq 0x277c0
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32fe0
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x32f30
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x25f63
jmp 0x25f82
leaq 0x2c34a(%rip), %rdi     # 0x522b4
leaq 0x2c2bf(%rip), %rsi     # 0x52230
movl $0x80a, %edx            # imm = 0x80A
leaq 0x2c346(%rip), %rcx     # 0x522c3
callq 0x6160
jmp 0x25f84
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x25ef2
movq -0x10(%rbp), %rdi
callq 0x6040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x26096
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33750
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2601f
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30600
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x2c2c2(%rip), %rsi     # 0x522da
movb $0x0, %al
callq 0x1dfe0
movq -0x30(%rbp), %rdi
callq 0x25450
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x32f30
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x2b1e0
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32f70
movq -0x30(%rbp), %rdi
callq 0x29190
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rdx
callq 0x33fe0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x25fbb
movq -0x10(%rbp), %rdi
callq 0x6040
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: postinfer
static void
postinfer(void)
{
	Postcheck **post;
	size_t npost, nlast;

	/* Iterate until we reach a fixpoint. */
	nlast = 0;
	while (1) {
		post = NULL;
		npost = 0;
		postcheckpass(&post, &npost);
		if (npost == nlast) {
			break;
		}
		nlast = npost;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2de60
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x26709
jmp 0x26713
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x266e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: stabsub
static void
stabsub(Stab *s)
{
	void **k;
	size_t n, i;
	Type *t;
	Node *d;
	char *dt;

	k = htkeys(s->ty, &n);
	for (i = 0; i < n; i++) {
		t = tysearch(gettype(s, k[i]));
		updatetype(s, k[i], t);
		tyfix(k[i], t, 0);
	}
	free(k);

	k = htkeys(s->dcl, &n);
	for (i = 0; i < n; i++) {
		d = getdcl(s, k[i]);
		pushenv(d->decl.env);
		d->decl.type = tyfix(d, d->decl.type, 0);
		popenv(d->decl.env);
		if (!d->decl.isconst && !d->decl.isgeneric)
			continue;
		if (d->decl.trait)
			continue;
		dt = "const";
		if (d->decl.isgeneric)
			dt = "generic";
		if (!d->decl.isimport && !d->decl.isextern && !d->decl.init)
			fatal(d, "non-extern %s \"%s\" has no initializer", dt, ctxstr(d));
	}
	free(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x267b2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33750
movq %rax, %rdi
callq 0x25450
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x33fe0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x28500
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26749
movq -0x10(%rbp), %rdi
callq 0x6040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x268e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x334b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32f70
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rsi
xorl %edx, %edx
callq 0x28500
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32fe0
movq -0x30(%rbp), %rax
cmpb $0x0, 0x72(%rax)
jne 0x26850
movq -0x30(%rbp), %rax
cmpb $0x0, 0x73(%rax)
jne 0x26850
jmp 0x268d0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2685d
jmp 0x268d0
leaq 0x2ac15(%rip), %rax     # 0x51479
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x73(%rax)
je 0x2687d
leaq 0x2ac0c(%rip), %rax     # 0x51485
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x77(%rax)
jne 0x268ce
movq -0x30(%rbp), %rax
cmpb $0x0, 0x74(%rax)
jne 0x268ce
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x268ce
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x27be0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x2c03c(%rip), %rsi     # 0x52903
movb $0x0, %al
callq 0x1dfe0
jmp 0x268d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x267d8
movq -0x10(%rbp), %rdi
callq 0x6040
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: verify
static void
verify(void)
{
	Type *t;
	Node *n;
	size_t i;

	pushstab(file.globls);
	/* for now, traits can only be declared globally */
	for (i = 0; i < file.nstmts; i++) {
		n = file.stmts[i];
		if (n->type == Nimpl) {
			/* we merge, so we need to get it back again when error checking */
			if (n->impl.isproto)
				fatal(n, "missing implementation for prototype '%s %s'",
					namestr(n->impl.traitname), tystr(n->impl.type));
		}
	}
	for (i = 0; i < ntypes; i++) {
		t = types[i];
		if (t->type != Tyarray)
			continue;
		t->asize = fold(t->asize, 1);
		if (t->asize && exprop(t->asize) != Olit)
			fatal(t->asize, "nonconstant array size near %s\n", ctxstr(t->asize));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x55ae9(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
callq 0x32db0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x55aca(%rip), %rcx     # 0x7cd98
cmpq 0x48(%rcx), %rax
jae 0x27353
leaq 0x55abd(%rip), %rax     # 0x7cd98
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xd, 0x8(%rax)
jne 0x27340
movq -0x10(%rbp), %rax
cmpb $0x0, 0x5c(%rax)
je 0x2733e
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x38a10
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x2b767(%rip), %rsi     # 0x52a9e
movb $0x0, %al
callq 0x1dfe0
jmp 0x27340
jmp 0x27342
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x272c3
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x5699a(%rip), %rcx     # 0x7dd00
cmpq (%rcx), %rax
jae 0x2741d
leaq 0x5697a(%rip), %rax     # 0x7dcf0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x15, (%rax)
je 0x27390
jmp 0x2740c
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
movl $0x1, %esi
callq 0x1f390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x2740a
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x2740a
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x27be0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x2b6c8(%rip), %rsi     # 0x52acb
movb $0x0, %al
callq 0x1dfe0
jmp 0x2740c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2735b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: findtrait
static Trait*
findtrait(Node *impl)
{
	Trait *tr;
	Node *n;
	Stab *ns;

	tr = impl->impl.trait;
	if (!tr) {
		n = impl->impl.traitname;
		ns = file.globls;
		if (n->name.ns)
			ns = getns(n->name.ns);
		if (ns)
			tr = gettrait(ns, n);
		if (!tr)
			fatal(impl, "trait %s does not exist near %s",
			    namestr(impl->impl.traitname), ctxstr(impl));
		if (tr->naux != impl->impl.naux)
			fatal(impl, "incompatible implementation of %s: mismatched aux types",
			    namestr(impl->impl.traitname), ctxstr(impl));
	}
	return tr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x277b6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x556b2(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2770d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x330b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27725
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33870
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27767
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27be0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x2a6d0(%rip), %rsi     # 0x51e30
movb $0x0, %al
callq 0x1dfe0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
je 0x277b4
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27be0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x2a6a3(%rip), %rsi     # 0x51e50
movb $0x0, %al
callq 0x1dfe0
jmp 0x277b6
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x277d5
jmp 0x277f4
leaq 0x2aa47(%rip), %rdi     # 0x52223
leaq 0x2aa4d(%rip), %rsi     # 0x52230
movl $0x289, %edx            # imm = 0x289
leaq 0x2aa49(%rip), %rcx     # 0x52238
callq 0x6160
movq -0x8(%rbp), %rdi
callq 0x2ab90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1d, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl 0x55bf4(%rip), %eax     # 0x7d410
movl %eax, 0x55bee(%rip)     # 0x7d410
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32f70
movq -0x18(%rbp), %rdi
callq 0x29190
movq -0x18(%rbp), %rdi
callq 0x34c90
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2785c
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29190
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32fe0
movq -0x8(%rbp), %rax
cmpl $0x1b, (%rax)
jne 0x2791a
movq -0x18(%rbp), %rax
cmpl $0x1d, (%rax)
jne 0x2791a
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
je 0x278ef
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x38a10
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38a10
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rax
leaq 0x554d3(%rip), %rsi     # 0x7cd98
movq 0x8(%rsi), %rsi
movq -0x18(%rbp), %rdi
movslq 0xc(%rdi), %rdi
movq (%rsi,%rdi,8), %r8
movq -0x18(%rbp), %rsi
movl 0x8(%rsi), %r9d
movq 0x8(%rax), %rdi
leaq 0x2a961(%rip), %rsi     # 0x52249
movb $0x0, %al
callq 0x1e110
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32f70
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2ad80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x32fe0
movl -0xc(%rbp), %ecx
movl 0x55aed(%rip), %eax     # 0x7d410
subl %ecx, %eax
movl %eax, 0x55ae5(%rip)     # 0x7d410
movq -0x18(%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: mktraitmap
static Traitmap *
mktraitmap(void)
{
	Traitmap *m;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x128, %edi            # imm = 0x128
callq 0x48160
movq %rax, -0x8(%rbp)
callq 0x48650
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq 0x89f4(%rip), %rdi      # 0x305b0
leaq 0x8aad(%rip), %rsi      # 0x30670
callq 0x48fe0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x281f4
movq -0x10(%rbp), %rdi
callq 0x30340
cmpq $0x0, %rax
je 0x281f4
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x25450
movq %rax, -0x18(%rbp)
jmp 0x28224
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0x28222
movq -0x10(%rbp), %rdi
callq 0x30260
cmpq $0x0, %rax
je 0x28222
movq -0x10(%rbp), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x25450
movq %rax, -0x18(%rbp)
jmp 0x28224
cmpq $0x0, -0x18(%rbp)
je 0x28248
movq -0x18(%rbp), %rdi
callq 0x36a30
cmpl $0x19, (%rax)
je 0x28248
movq -0x18(%rbp), %rdi
callq 0x38a10
movq %rax, -0x8(%rbp)
jmp 0x28258
leaq 0x29cbc(%rip), %rdi     # 0x51f0b
callq 0x6330
movq %rax, -0x8(%rbp)
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: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x54821(%rip), %rax     # 0x7d2d0
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x28acc
jmp 0x28bcf
movq -0x28(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x28b01
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x28b01
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
jmp 0x28b0c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x28b20
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x48b40
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jae 0x28b89
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x254b0
cmpl $0x0, %eax
jl 0x28b79
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rax), %rsi
callq 0x48a50
jmp 0x28b7b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x28b28
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x28ba6
movq -0x28(%rbp), %rax
cmpq $0x1, 0x70(%rax)
je 0x28ba8
jmp 0x28bcf
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x28abe
movq -0x8(%rbp), %rax
cmpl $0x1c, (%rax)
je 0x28bda
jmp 0x28bee
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x28aa0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: tyrank
static int
tyrank(Type *t)
{
	if (t->type == Tyvar) {
		/* has associated iterator type */
		if (t->seqaux)
			return 1;
		else
			return 0;
	}
	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x296de
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x296d5
movl $0x1, -0x4(%rbp)
jmp 0x296e5
movl $0x0, -0x4(%rbp)
jmp 0x296e5
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: occursin
static int
occursin(Type *a, Type *b)
{
	Bitset *bs;
	int r;

	bs = mkbs();
	a = tf(a);
	bsput(bs, a->tid);
	r = occurs_rec(b, bs);
	bsfree(bs);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x48650
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x277c0
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x48a50
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a100
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48690
movl -0x1c(%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: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x277c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpq 0x53c85(%rip), %rax     # 0x7d400
jb 0x297c0
movq 0x53c84(%rip), %rdi     # 0x7d408
movq 0x53c75(%rip), %rsi     # 0x7d400
shlq $0x3, %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x481f0
movq %rax, 0x53c5b(%rip)     # 0x7d408
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, 0x53c40(%rip)     # 0x7d400
movq 0x53c41(%rip), %rax     # 0x7d408
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
cmpl $0x0, (%rax,%rcx,8)
jg 0x297ea
movq 0x53c2d(%rip), %rax     # 0x7d408
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x29821
movq -0x8(%rbp), %rax
cmpl $0x1c, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2982a
jmp 0x29847
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x29808
cmpq $0x0, -0x10(%rbp)
jne 0x29878
movq -0x8(%rbp), %rax
cmpl $0x14, (%rax)
je 0x29869
movq -0x8(%rbp), %rax
cmpl $0x15, (%rax)
je 0x29869
movq -0x8(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x29878
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2988c
movq -0x10(%rbp), %rdi
callq 0x277c0
movq %rax, -0x10(%rbp)
movq -0x10(%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: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %edx
callq 0x28500
movq %rax, %rdi
callq 0x38a10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %edx
callq 0x28500
movq %rax, %rdi
callq 0x38a10
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a2d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a2d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27be0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29b85
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x20(%rbp), %r9
movq -0x38(%rbp), %r10
movq -0x40(%rbp), %rax
leaq 0x28514(%rip), %rsi     # 0x52089
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1dfe0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %rax
leaq 0x28516(%rip), %rsi     # 0x520ba
movq %rax, (%rsp)
movb $0x0, %al
callq 0x1dfe0
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: mergetraits
static void
mergetraits(Node *ctx, Type *a, Type *b)
{
	if (b->type == Tyvar) {
		/* make sure that if a = b, both have same traits */
		if (a->trneed && b->trneed)
			bsunion(b->trneed, a->trneed);
		else if (a->trneed)
			b->trneed = bsdup(a->trneed);
		else if (b->trneed)
			a->trneed = bsdup(b->trneed);
	} else {
		verifytraits(ctx, a, b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x29fea
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29f8a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29f8a
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rsi
callq 0x48b40
jmp 0x29fe8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29fb8
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x486d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
jmp 0x29fe6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x29fe4
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x486d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
jmp 0x29fe6
jmp 0x29fe8
jmp 0x29ffb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29be0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: membunify
static void
membunify(Node *ctx, Type *u, Type *v)
{
	if (hthas(delayed, u))
		u = htget(delayed, u);
	u = tybase(u);
	if (hthas(delayed, v))
		v = htget(delayed, v);
	v = tybase(v);
	if (u->type == Tyunion && v->type == Tyunion && u != v)
		unionunify(ctx, u, v);
	else if (u->type == Tystruct && v->type == Tystruct && u != v)
		structunify(ctx, u, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x53295(%rip), %rdi     # 0x7d2c0
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x2a04d
movq 0x53280(%rip), %rdi     # 0x7d2c0
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq 0x5325f(%rip), %rdi     # 0x7d2c0
movq -0x18(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x2a083
movq 0x5324a(%rip), %rdi     # 0x7d2c0
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36a30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x2a0bf
movq -0x18(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x2a0bf
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x2a0bf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a3d0
jmp 0x2a0ee
movq -0x10(%rbp), %rax
cmpl $0x17, (%rax)
jne 0x2a0ec
movq -0x18(%rbp), %rax
cmpl $0x17, (%rax)
jne 0x2a0ec
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x2a0ec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a6c0
jmp 0x2a0ee
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x277c0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x27430
cmpl $0x0, %eax
je 0x2a140
movl $0x1, -0x4(%rbp)
jmp 0x2a2bd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x48a50
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x6, %eax
ja 0x2a255
movq -0x28(%rbp), %rax
leaq 0x27817(%rip), %rcx     # 0x5198c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2a2a4
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2a1de
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2a100
cmpl $0x0, %eax
je 0x2a1ce
movl $0x1, -0x4(%rbp)
jmp 0x2a2bd
jmp 0x2a1d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a18b
jmp 0x2a2a4
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2a253
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x28(%rax)
jne 0x2a215
jmp 0x2a245
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a100
cmpl $0x0, %eax
je 0x2a243
movl $0x1, -0x4(%rbp)
jmp 0x2a2bd
jmp 0x2a245
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a1eb
jmp 0x2a2a4
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x2a2a2
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a100
cmpl $0x0, %eax
je 0x2a292
movl $0x1, -0x4(%rbp)
jmp 0x2a2bd
jmp 0x2a294
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a25d
jmp 0x2a2a4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x48af0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)