LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x17f08
movq %rdi, %rbx
leaq 0x4741d(%rip), %r15     # 0x5f1d0
movq (%r15), %rcx
movq %rdi, %r14
movl 0x4(%r14), %edx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x17e18
cmpl $0x1b, (%r14)
jne 0x17e18
callq 0x1d859
movq 0x88(%r14), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x17de4
callq 0x1da38
movq 0x88(%r14), %rsi
testq %rax, %rax
je 0x17ed2
movq %rax, %rdi
callq 0x1dda3
testq %rax, %rax
je 0x17ee5
movq (%r15), %rcx
movl 0x4(%r14), %edx
cmpq %r14, %rax
je 0x17e18
movq %rax, (%rcx,%rdx,8)
movq (%r15), %rcx
movq (%rcx,%rdx,8), %rax
testq %rax, %rax
je 0x17e40
movl 0x4(%rax), %esi
movq (%rcx,%rsi,8), %rsi
movq %rax, %r14
testq %rsi, %rsi
je 0x17db9
movq %rsi, (%rcx,%rdx,8)
movq (%r15), %rcx
movq (%rcx,%rdx,8), %r14
jmp 0x17db9
xorl %ebp, %ebp
cmpl $0x1d, (%r14)
sete %bpl
addl %ebp, 0x46aa0(%rip)     # 0x5e8f0
movq 0x60(%rbx), %rdi
callq 0x1d970
movq %r14, %rdi
callq 0x192e3
movq %r14, %rdi
callq 0x1e938
testq %rax, %rax
je 0x17e7c
movq %rax, %r15
movq %rax, %rdi
callq 0x192e3
movq %r15, %r14
movq 0x60(%rbx), %rdi
callq 0x1d9bb
cmpl $0x1b, (%rbx)
jne 0x17ebe
cmpl $0x1d, (%r14)
jne 0x17ebe
movq 0x38(%r14), %rax
cmpq 0x48(%rbx), %rax
jne 0x17f27
movq 0x60(%rbx), %rdi
callq 0x1d970
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19c17
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x1d9bb
subl %ebp, 0x46a2c(%rip)     # 0x5e8f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsi), %rdx
leaq 0x1a3fb(%rip), %rax     # 0x322d8
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x17f01
movq 0x88(%r14), %rbx
movq %r14, %rdi
callq 0x21009
leaq 0x1a3ef(%rip), %rsi     # 0x322ea
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x120fd
leaq 0x1a36c(%rip), %rdi     # 0x3227b
leaq 0x1a372(%rip), %rsi     # 0x32288
leaq 0x1a373(%rip), %rcx     # 0x32290
movl $0x289, %edx            # imm = 0x289
callq 0x4180
movq %rbx, %rdi
callq 0x21009
movq %rax, %r15
movq %r14, %rdi
callq 0x21009
leaq 0x46337(%rip), %rcx     # 0x5e278
movq 0x8(%rcx), %rcx
movslq 0xc(%r14), %rdx
movq (%rcx,%rdx,8), %r8
movl 0x8(%r14), %r9d
movq 0x8(%rbx), %rdi
leaq 0x1a345(%rip), %rsi     # 0x322a1
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x121e4
// File: /workspace/github_c_makefile_star2_O2/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 0x29a78
movq %rax, %rbx
callq 0x29d3c
movq %rax, (%rbx)
leaq 0x4117(%rip), %rdi      # 0x1c09d
leaq 0x4173(%rip), %rsi      # 0x1c100
callq 0x2a188
movq %rax, 0x100(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x8(%rdi), %eax
cmpl $0x8, %eax
jne 0x18585
movq %rbx, %rdi
callq 0x1bf90
testq %rax, %rax
je 0x18582
movq %rbx, %rdi
callq 0x1bf90
jmp 0x1859f
movl 0x8(%rbx), %eax
cmpl $0xb, %eax
jne 0x185bc
movq %rbx, %rdi
callq 0x1bf2d
testq %rax, %rax
je 0x185bc
movq %rbx, %rdi
callq 0x1bf2d
movq %rax, %rdi
callq 0x1589c
testq %rax, %rax
je 0x185bc
movq %rax, %rbx
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x19, (%rax)
jne 0x185c9
leaq 0x199a0(%rip), %rdi     # 0x31f63
popq %rbx
jmp 0x4340
movq %rbx, %rdi
popq %rbx
jmp 0x21009
// File: /workspace/github_c_makefile_star2_O2/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 0x45e1e(%rip), %rcx     # 0x5e7b0
movl (%r14), %eax
movq 0x8(%rcx,%rax,8), %r12
movq %r14, %r15
cmpl $0x1c, %eax
je 0x189ac
cmpl $0x19, %eax
jne 0x189b3
jmp 0x18a44
cmpq $0x0, 0x38(%r15)
je 0x18a28
movq (%r12), %rsi
testq %rsi, %rsi
je 0x189c4
movq %rbx, %rdi
callq 0x29f5f
xorl %r13d, %r13d
cmpq 0x110(%r12), %r13
jae 0x18a05
movq 0x108(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x158be
testl %eax, %eax
js 0x18a00
movq 0x118(%r12), %rax
movq (%rax,%r13,8), %rax
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x29ed5
incq %r13
jmp 0x189c7
movl (%r15), %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
je 0x18a44
cmpq $0x1, 0x70(%r15)
jne 0x18a44
movq 0x68(%r15), %rax
movq (%rax), %r15
movl (%r15), %eax
jmp 0x1899d
movq 0x100(%r12), %rdi
movq 0x88(%r15), %rsi
callq 0x2a3e8
movq %rax, %rsi
jmp 0x189b7
cmpl $0x1c, (%r14)
jne 0x18a56
movq 0x68(%r14), %rax
movq (%rax), %r14
jmp 0x1898b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17d99
movq %rax, %r14
movl 0x4(%rax), %edx
movq 0x452cf(%rip), %rsi     # 0x5e8e0
movq 0x452d0(%rip), %rax     # 0x5e8e8
cmpq %rdx, %rsi
ja 0x19644
shlq $0x3, %rsi
incl %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x29ad0
movq %rax, 0x452b2(%rip)     # 0x5e8e8
movl 0x4(%r14), %edx
leal 0x1(%rdx), %ecx
movq %rcx, 0x4529c(%rip)     # 0x5e8e0
cmpl $0x0, (%rax,%rdx,8)
jg 0x1964e
movq %rbx, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19688
movl (%rdi), %eax
cmpl $0x1c, %eax
jne 0x1966f
movq 0x68(%rdi), %rax
movq (%rax), %rdi
jmp 0x19656
leal -0x14(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1967c
cmpl $0x12, %eax
jne 0x19690
movq 0x68(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x19690
movq %rax, %rdi
jmp 0x17d99
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r13
xorl %edi, %edi
movq %r12, %rsi
movl %r13d, %edx
callq 0x185d2
movq %rax, %rdi
callq 0x21009
movq %rax, %r15
xorl %edi, %edi
movq %rbp, %rsi
movl %r13d, %edx
callq 0x185d2
movq %rax, %rdi
callq 0x21009
movq %rax, %r13
movq %r12, %rdi
callq 0x19a61
movq %rax, %r12
movq %rbp, %rdi
callq 0x19a61
movq %rax, %rbp
movq %r14, %rdi
callq 0x17f9e
testq %rbx, %rbx
jne 0x19723
subq $0x8, %rsp
leaq 0x18a06(%rip), %rsi     # 0x32112
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %rbp
callq 0x120fd
leaq 0x189b7(%rip), %rsi     # 0x320e1
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
pushq %rbp
pushq %r12
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x17d99
movq %rax, %r14
movl 0x4(%rax), %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17d72
pushq $0x1
popq %rbp
testl %eax, %eax
jne 0x199d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29ed5
movl (%r14), %eax
addl $-0x12, %eax
cmpl $0x6, %eax
ja 0x19a3c
leaq 0x180ef(%rip), %rcx     # 0x31aac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x29f3e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
cmpq 0x78(%r14), %r15
jae 0x199c6
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x19a0a
movq %rbx, %rsi
callq 0x19974
testl %eax, %eax
jne 0x199d4
incq %r15
jmp 0x199e4
xorl %r15d, %r15d
cmpq 0x78(%r14), %r15
jae 0x199c6
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1bf2d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19974
incq %r15
testl %eax, %eax
je 0x19a12
jmp 0x199d4
xorl %r15d, %r15d
cmpq 0x70(%r14), %r15
jae 0x199c6
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x19974
incq %r15
testl %eax, %eax
je 0x19a3f
jmp 0x199d4
// File: /workspace/github_c_makefile_star2_O2/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, 0x44e65(%rip)     # 0x5e8e0
jbe 0x19ad0
movq 0x44e64(%rip), %rcx     # 0x5e8e8
cmpl $0x0, (%rcx,%rax,8)
jle 0x19ad0
movq (%rcx,%rax,8), %rbx
callq 0x21009
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b4f4
movq %rax, %r15
movq %rbx, %rdi
callq 0x1b508
leaq 0x1868f(%rip), %rdx     # 0x3213f
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_O2/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 %rbx
movl 0x8(%rdi), %eax
leal -0x8(%rax), %ecx
cmpl $0x4, %ecx
ja 0x19bcc
movq %rdi, %rbx
leaq 0x17fc9(%rip), %rdx     # 0x31ac8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x20(%rbx), %rdi
jmp 0x19bc2
movq %rbx, %rdi
callq 0x1bf2d
movq %rax, %rdi
jmp 0x19bc2
movq 0x28(%rbx), %rdi
jmp 0x19bc2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0x19bc2
movl 0x18(%rbx), %eax
cmpq $0x7, %rax
ja 0x19bc8
leaq 0x17f91(%rip), %rcx     # 0x31adc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
pushq $0x3
jmp 0x19b93
movq (%rbx), %rdi
pushq $0x9
popq %rsi
callq 0x1fdc2
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x201d8
jmp 0x19bbb
movq (%rbx), %rdi
pushq $0x6
jmp 0x19b7f
movq (%rbx), %rdi
pushq $0x10
popq %rsi
callq 0x19be5
jmp 0x19bbb
movq (%rbx), %rdi
pushq $0x1
jmp 0x19b93
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x1fdc2
jmp 0x19bbb
movq 0x30(%rbx), %rax
movq 0x28(%rax), %rdi
jmp 0x19bbe
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1fdc2
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x2020c
movq %rax, %rdi
movq %rdi, 0x20(%rbx)
popq %rbx
jmp 0x17d99
xorl %edi, %edi
jmp 0x19bbe
leaq 0x440cd(%rip), %rcx     # 0x5dca0
movq (%rcx,%rax,8), %rsi
leaq 0x185d4(%rip), %rdi     # 0x321b2
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 0x1c2cd
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19c4c
movq %rax, %rbx
movq %r15, %rdi
callq 0x1c319
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r13d, %r13d
cmpq 0x38(%rbx), %r13
jae 0x19c8f
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %r12
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x17d99
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1c27c
incq %r13
jmp 0x19c61
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x19ca0
// File: /workspace/github_c_makefile_star2_O2/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 0x29d3c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19d55
movl %eax, %ebp
movq %r15, %rdi
callq 0x29d60
testl %ebp, %ebp
je 0x19cf3
movq 0x60(%rbx), %rdi
callq 0x1d970
testq %r14, %r14
je 0x19cf8
movq 0x44abd(%rip), %rdx     # 0x5e7a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c34e
movq %rax, %r14
jmp 0x19d1d
movq %rbx, %r14
jmp 0x19d47
callq 0x1c2cd
movq %rax, %r15
movq 0x44a99(%rip), %rdx     # 0x5e7a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c34e
movq %rax, %r14
movq %r15, %rdi
callq 0x1c319
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x19656
testq %rax, %rax
je 0x19d3e
movq %rax, 0x28(%r14)
movq 0x60(%rbx), %rdi
callq 0x1d9bb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
pushq $0x1
popq %rbp
leaq 0x17d8f(%rip), %r13     # 0x31afc
xorl %ebx, %ebx
callq 0x1589c
movq %rax, %r15
movl 0x4(%rax), %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x17d72
testl %eax, %eax
jne 0x19e63
movq %r14, %rdi
movq %r12, %rsi
callq 0x29ed5
movl (%r15), %eax
addl $-0x17, %eax
cmpl $0x6, %eax
ja 0x19e3f
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
xorl %r12d, %r12d
cmpq 0x48(%r15), %r12
jae 0x19dd7
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x19d55
incq %r12
testl %eax, %eax
je 0x19db5
jmp 0x19e61
movq 0x68(%r15), %rax
movq (%rax), %rdi
jmp 0x19d6f
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq 0x78(%r15), %r12
jae 0x19e63
movq 0x88(%r15), %rax
movq (%rax,%r12,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x19e0b
movq %r14, %rsi
callq 0x19d55
testl %eax, %eax
jne 0x19e61
incq %r12
jmp 0x19de5
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq 0x78(%r15), %r12
jae 0x19e63
movq 0x88(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x1bf2d
movq %rax, %rdi
movq %r14, %rsi
callq 0x19d55
incq %r12
testl %eax, %eax
je 0x19e15
jmp 0x19e61
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq 0x70(%r15), %r12
jae 0x19e63
movq 0x68(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x19d55
incq %r12
testl %eax, %eax
je 0x19e44
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bf2d
movq %rax, %rdi
callq 0x17d99
movq %rax, %r14
cmpl $0x1d, (%rax)
jne 0x19eff
cmpb $0x0, 0x73(%rbx)
jne 0x19eff
xorl %edi, %edi
movq %r14, %rsi
callq 0x19ca0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf2d
movq %rax, %r15
movl (%r14), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x19eff
movl (%r15), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x19eff
movq 0x48(%r14), %rax
cmpq 0x48(%r15), %rax
jne 0x19f7a
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x19eff
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rsi
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
callq 0x18a60
incq %r12
movq 0x48(%r14), %rax
jmp 0x19ed9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aea7
cmpq $0x0, 0x30(%rbx)
je 0x19f52
leaq 0x30(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a2da
movq %rbx, %rdi
callq 0x19ae5
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19ae5
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x18a60
cmpb $0x0, 0x72(%rbx)
je 0x19f52
movq (%r14), %rax
cmpl $0x0, 0x30(%rax)
je 0x19f5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x17f9e
leaq 0x1840b(%rip), %rsi     # 0x32378
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x120fd
movq %r14, %rdi
callq 0x21009
movq %rax, %r14
movq %r15, %rdi
callq 0x21009
movq %rax, %r15
movq %rbx, %rdi
callq 0x17f9e
leaq 0x183f8(%rip), %rsi     # 0x32397
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x29aa7
movq %rax, %r14
movq %rbx, (%rax)
callq 0x1d859
movq %rax, 0x8(%r14)
callq 0x1d954
movq %rax, 0x10(%r14)
leaq 0x44664(%rip), %rdi     # 0x5e928
leaq 0x44665(%rip), %rsi     # 0x5e930
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29b2d
// File: /workspace/github_c_makefile_star2_O2/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 0x17d99
movl 0x8(%rbx), %ecx
leal -0x8(%rcx), %edx
cmpl $0x5, %edx
jae 0x1aeea
pushq $0x1b
popq %rsi
btl %edx, %esi
jae 0x1aeea
movl %edx, %ecx
leaq 0x16f91(%rip), %rdx     # 0x31e60
movq (%rdx,%rcx,8), %rcx
movq %rax, (%rbx,%rcx)
cmpl $0x19, (%rax)
jne 0x1aede
popq %rbx
retq
movq (%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x195f8
leaq 0x42daf(%rip), %rax     # 0x5dca0
movq (%rax,%rcx,8), %rsi
leaq 0x174c9(%rip), %rdi     # 0x323c5
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 0x1afe7
movq %rsi, %r14
movq 0x50(%rbx), %r13
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x2a, %eax
jne 0x1afe7
movq (%r13), %rdi
callq 0x1b5e6
cmpl $0x33, %eax
jne 0x1afe7
movq (%r13), %rax
movq 0x50(%rax), %rax
movq (%rax), %r12
movq %r12, %rdi
callq 0x1c0c8
movq %rax, %rdi
callq 0x1da38
testq %rax, %rax
je 0x1afe7
movq %rax, %r15
callq 0x1d859
movq %rax, %rdi
movq %r12, %rsi
callq 0x1dc67
testq %rax, %rax
jne 0x1afe7
movq %r12, %rdi
callq 0x1c0c8
movq %rax, %r12
movq 0x8(%r13), %rdi
callq 0x1c0c8
movq (%rbx), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1bd23
movq %rax, %r12
movq 0x8(%r13), %rsi
movq %r15, %rdi
callq 0x1dc67
testq %rax, %rax
je 0x1aff4
movq %rax, %r15
movq (%rbx), %rdi
pushq $0x33
popq %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r12
movq 0x48(%rbx), %rax
movq %rax, 0x48(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1b1c1
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 0x17473(%rip), %rsi     # 0x32478
movq %rbx, %rdi
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/infer.c
// Function: inferucon
static void
inferucon(Node *n, int *isconst)
{
	Ucon *uc;
	Type *t;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, (%rsi)
movq 0x50(%rdi), %r12
callq 0x1d859
movq (%r12), %rsi
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x1b042
callq 0x1da38
movq (%r12), %rsi
testq %rax, %rax
je 0x1b163
movq %rax, %rdi
callq 0x1de08
testq %rax, %rax
je 0x1b173
movq %rax, %r15
cmpq $0x0, 0x28(%rax)
movq 0x40(%rbx), %rax
je 0x1b085
cmpq $0x2, %rax
je 0x1b08f
movq (%r12), %rdi
callq 0x17f9e
leaq 0x174d0(%rip), %rsi     # 0x32550
jmp 0x1b1b4
cmpq $0x2, %rax
jae 0x1b1a4
movq 0x20(%r15), %r12
cmpl $0x18, (%r12)
je 0x1b0ad
movq 0x68(%r12), %rax
movq (%rax), %r12
cmpl $0x18, (%r12)
jne 0x1b185
movq %r12, %rdi
callq 0x17d99
movq %rax, %rdi
movq %r12, %rsi
callq 0x19c17
movq %rax, %rdi
callq 0x1fcd8
movq 0x88(%rax), %rax
movq 0x8(%r15), %rcx
movq (%rax,%rcx,8), %r12
cmpq $0x0, 0x28(%r12)
je 0x1b11e
movq 0x50(%rbx), %rdi
addq $0x8, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a2da
movq 0x28(%r12), %r15
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x19ae5
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x18a60
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, (%r14)
movq 0x20(%r12), %r14
cmpl $0x18, (%r14)
jne 0x1b14d
movq 0x8(%r14), %rdi
pushq $0x18
popq %rsi
callq 0x19be5
movq %rax, %r15
movq 0x43661(%rip), %rdi     # 0x5e7a0
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a22a
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1aea7
movq 0x18(%rsi), %rdx
leaq 0x1738e(%rip), %rsi     # 0x324fc
movq %rbx, %rdi
jmp 0x1b1ba
movq (%r12), %rdi
callq 0x17f9e
leaq 0x1738a(%rip), %rsi     # 0x3250d
jmp 0x1b1b4
leaq 0x1733f(%rip), %rdi     # 0x324cb
leaq 0x170f5(%rip), %rsi     # 0x32288
leaq 0x17344(%rip), %rcx     # 0x324de
movl $0x5e8, %edx            # imm = 0x5E8
callq 0x4180
movq (%r12), %rdi
callq 0x17f9e
leaq 0x17372(%rip), %rsi     # 0x32526
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/infer.c
// Function: infersub
static void
infersub(Node *n, Type *ret, int *sawret, int *exprconst)
{
	Node **args;
	size_t i, nargs;
	int isconst;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b5e6
cmpl $0x33, %eax
je 0x1b447
movq %rbx, (%rsp)
movq 0x40(%r14), %rbx
movq 0x50(%r14), %r13
pushq $0x1
popq %rbp
subq $0x1, %rbx
jb 0x1b420
movq (%r13), %rdi
cmpl $0x8, 0x8(%rdi)
jne 0x1b41a
movq %r13, %rsi
callq 0x1af03
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1a2da
testl %ebp, %ebp
je 0x1b418
movq (%r13), %rax
xorl %ebp, %ebp
cmpl $0x0, 0x30(%rax)
setne %bpl
jmp 0x1b41a
xorl %ebp, %ebp
addq $0x8, %r13
jmp 0x1b3de
movq %r14, %rdi
callq 0x1b5e6
movl %eax, %eax
leaq 0x4256f(%rip), %rcx     # 0x5d9a0
cmpl $0x0, (%rcx,%rax,4)
je 0x1b43d
movl %ebp, 0x30(%r14)
jmp 0x1b441
movl 0x30(%r14), %ebp
movq (%rsp), %rax
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/infer.c
// Function: itertype
static Type *
itertype(Node *n, Type *ret)
{
	Type *it, *val, *itp, *valp, *fn;

	it = exprtype(n);
	itp = mktyptr(n->loc, it);
	val = basetype(it);
	if (!val)
		die("FAIL! %s", tystr(it));
	valp = mktyptr(n->loc, val);
	fn = mktyfunc(n->loc, NULL, 0, ret);
	lappend(&fn->sub, &fn->nsub, itp);
	lappend(&fn->sub, &fn->nsub, valp);
	return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1bf90
movq %rax, %r12
movq (%r15), %rdi
movq %rax, %rsi
callq 0x2020c
movq %rax, %r14
movq %r12, %rdi
callq 0x19656
testq %rax, %rax
je 0x1b4d9
movq (%r15), %rdi
movq %rax, %rsi
callq 0x2020c
movq %rax, %r12
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2028c
movq %rax, %rbx
leaq 0x68(%rax), %r15
leaq 0x70(%rax), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x29b2d
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x29b2d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x21009
leaq 0x175af(%rip), %rdi     # 0x32a97
movq %rax, %rsi
xorl %eax, %eax
callq 0x1205c
nop
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: initfile
void
initfile(File *f, char *name)
{
	memset(f, 0, sizeof(*f));
	f->builtins = mkstab(0);
	f->globls = mkstab(0);
	f->globls->super = file.builtins;
	f->ns = mkht(strhash, streq);
	lappend(&f->files, &f->nfiles, name);
	tyinit(f->builtins);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa8, %edx
xorl %esi, %esi
callq 0x41a0
xorl %edi, %edi
callq 0x1d73b
movq %rax, 0x98(%rbx)
xorl %edi, %edi
callq 0x1d73b
movq %rax, 0x90(%rbx)
leaq 0x42d33(%rip), %rcx     # 0x5e278
movq 0x98(%rcx), %rcx
movq %rcx, (%rax)
leaq 0xf02d(%rip), %rdi      # 0x2a583
leaq 0xf0c9(%rip), %rsi      # 0x2a626
callq 0x2a188
movq %rax, 0xa0(%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x29b2d
movq 0x98(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21e2d
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: arraysz
uvlong
arraysz(Node *sz)
{
	Node *n;

        if (!sz)
		return 0;
        n = fold(sz, 1);
	if (exprop(n) != Olit)
		fatal(sz, "too much indirection when finding initializer. (initialization loop?)");

	n = n->expr.args[0];
	if (n->lit.littype != Lint)
		fatal(sz, "initializer is not an integer");
	return n->lit.intval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b5c2
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x12bd3
movq %rax, %r14
movq %rax, %rdi
callq 0x1b5e6
cmpl $0x35, %eax
jne 0x1b5cc
movq 0x50(%r14), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0x1b5d5
movq 0x30(%rax), %rax
jmp 0x1b5c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x17899(%rip), %rsi     # 0x32e6c
jmp 0x1b5dc
leaq 0x178d6(%rip), %rsi     # 0x32eb2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mknode
Node *
mknode(Srcloc loc, Ntype nt)
{
	Node *n;

	n = zalloc(sizeof(Node));
	n->nid = nnodes;
	n->type = nt;
	n->loc = loc;
	lappend(&nodes, &nnodes, n);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x80, %edi
callq 0x29a78
movq %rax, %r15
leaq 0x4331a(%rip), %rsi     # 0x5e948
movl 0x43314(%rip), %eax     # 0x5e948
movl %eax, 0xc(%r15)
movl %ebx, 0x8(%r15)
movq %r14, (%r15)
leaq 0x4330a(%rip), %rdi     # 0x5e950
movq %r15, %rdx
callq 0x29b2d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkuse
Node *
mkuse(Srcloc loc, char *use, int islocal)
{
	Node *n;

	n = mknode(loc, Nuse);
	n->use.name = strdup(use);
	n->use.islocal = islocal;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
pushq $0x7
popq %rsi
callq 0x1b610
movq %rax, %r15
movq %r14, %rdi
callq 0x4340
movq %rax, 0x20(%r15)
movl %ebx, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mksliceexpr
Node *
mksliceexpr(Srcloc loc, Node *sl, Node *base, Node *off)
{
	if (!base)
		base = mkintlit(loc, 0);
	if (!off)
		off = mkexpr(loc, Omemb, sl, mkname(loc, "len"), NULL);
	return mkexpr(loc, Oslice, sl, base, off, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jne 0x1b6ab
movq %r14, %rdi
xorl %esi, %esi
callq 0x1b6fc
movq %rax, %r15
testq %r12, %r12
jne 0x1b6d8
leaq 0x193c1(%rip), %rsi     # 0x34a78
movq %r14, %rdi
callq 0x1b7fd
pushq $0x2a
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %r12
pushq $0x29
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %r9d, %r9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1b718
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkexpr
Node *
mkexpr(Srcloc loc, int op, ...)
{
	Node *n;
	va_list ap;
	Node *arg;

	n = mknode(loc, Nexpr);
	n->expr.op = op;
	va_start(ap, op);
	while ((arg = va_arg(ap, Node *)) != NULL)
		lappend(&n->expr.args, &n->expr.nargs, arg);
	va_end(ap);

	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %esi, %ebp
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1b777
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
pushq $0x8
popq %rsi
callq 0x1b610
movq %rax, %rbx
movl %ebp, 0x18(%rax)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x50(%rbx), %r14
movq %rbx, %r15
addq $0x40, %r15
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1b7c9
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1b7d7
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1b7ec
movq %r14, %rdi
movq %r15, %rsi
callq 0x29b2d
jmp 0x1b7b0
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkexprl
Node *
mkexprl(Srcloc loc, Op op, Node **args, size_t nargs)
{
	Node *n;

	n = mknode(loc, Nexpr);
	n->expr.op = op;
	n->expr.args = args;
	n->expr.nargs = nargs;
	return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
pushq $0x8
popq %rsi
callq 0x1b610
movl %ebp, 0x18(%rax)
movq %r14, 0x50(%rax)
movq %rbx, 0x40(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkcall
Node *
mkcall(Srcloc loc, Node *fn, Node **args, size_t nargs)
{
	Node *n;
	size_t i;

	n = mkexpr(loc, Ocall, fn, NULL);
	for (i = 0; i < nargs; i++)
		lappend(&n->expr.args, &n->expr.nargs, args[i]);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rdx
xorl %ebp, %ebp
pushq $0x2d
popq %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r15
leaq 0x50(%rax), %r12
movq %rax, %r13
addq $0x40, %r13
cmpq %rbp, %rbx
je 0x1b893
movq (%r14,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x29b2d
incq %rbp
jmp 0x1b87a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkifstmt
Node *
mkifstmt(Srcloc loc, Node *cond, Node *iftrue, Node *iffalse)
{
	Node *n;

	n = mknode(loc, Nifstmt);
	n->ifstmt.cond = cond;
	n->ifstmt.iftrue = iftrue;
	n->ifstmt.iffalse = iffalse;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
pushq $0x2
popq %rsi
callq 0x1b610
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkloopstmt
Node *
mkloopstmt(Srcloc loc, Node *init, Node *cond, Node *incr, Node *body)
{
	Node *n;

	n = mknode(loc, Nloopstmt);
	n->loopstmt.init = init;
	n->loopstmt.cond = cond;
	n->loopstmt.step = incr;
	n->loopstmt.body = body;
	n->loopstmt.scope = mkstab(0);

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
pushq $0x3
popq %rsi
callq 0x1b610
movq %rax, %r13
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
xorl %edi, %edi
callq 0x1d73b
movq %rax, 0x38(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkmatchstmt
Node *
mkmatchstmt(Srcloc loc, Node *val, Node **matches, size_t nmatches)
{
	Node *n;

	n = mknode(loc, Nmatchstmt);
	n->matchstmt.val = val;
	n->matchstmt.matches = matches;
	n->matchstmt.nmatches = nmatches;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
pushq $0x5
popq %rsi
callq 0x1b610
movq %r15, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkmatch
Node *
mkmatch(Srcloc loc, Node *pat, Node *body)
{
	Node *n;

	n = mknode(loc, Nmatch);
	n->match.pat = pat;
	n->match.block = body;
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x6
popq %rsi
callq 0x1b610
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkfunc
Node *
mkfunc(Srcloc loc, Node **args, size_t nargs, Type *ret, Node *body)
{
	Node *n;
	Node *f;
	size_t i;
	Stab *st;

	f = mknode(loc, Nfunc);
	f->func.args = args;
	f->func.nargs = nargs;
	f->func.body = body;
	f->func.scope = mkstab(1);
	f->func.type = mktyfunc(loc, args, nargs, ret);
	f->func.env = mkenv();

	bindtype(f->func.env, f->func.type);
	st = body->block.scope;
	for (i = 0; i < nargs; i++)
		putdcl(st, args[i]);

	n = mknode(loc, Nlit);
	n->lit.littype = Lfunc;
	n->lit.fnval = f;
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0xc
popq %rsi
callq 0x1b610
movq %rax, %r14
movq %r12, 0x38(%rax)
movq %r15, 0x30(%rax)
movq %r13, 0x40(%rax)
pushq $0x1
popq %rdi
callq 0x1d73b
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x2028c
movq %rax, 0x28(%r14)
callq 0x1d928
movq %rax, 0x18(%r14)
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x1e6ec
movq 0x18(%r13), %r13
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x1ba0a
movq (%r12,%rbp,8), %rsi
movq %r13, %rdi
callq 0x1deda
incq %rbp
jmp 0x1b9f4
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x1b610
movl $0x5, 0x18(%rax)
movq %r14, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkimplstmt
Node *
mkimplstmt(Srcloc loc, Node *name, Type *t, Type **aux, size_t naux, Node **decls, size_t ndecls)
{
	Node *n;
	size_t i;

	n = mknode(loc, Nimpl);
	n->impl.traitname = name;
	n->impl.type = t;
	n->impl.aux = aux;
	n->impl.naux = naux;
	n->impl.decls = decls;
	n->impl.ndecls = ndecls;
	lappend(&impltab, &nimpltab, n);
	if (hasparams(t)) {
		n->impl.env = mkenv();
		bindtype(n->impl.env, t);
	}
	for (i = 0; i < naux; i++)
		if (hasparams(aux[i]))
			bindtype(n->impl.env, aux[i]);
	for (i = 0; i < ndecls; i++) {
		if (name->name.ns)
			setns(decls[i]->decl.name, name->name.ns);
		if (decls[i]->decl.env)
			decls[i]->decl.env->super = n->impl.env;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
pushq $0xd
popq %rsi
callq 0x1b610
movq %rax, %r15
movq %r14, 0x18(%rax)
movq %rbp, 0x28(%rax)
movq %r13, 0x30(%rax)
movq %r12, 0x40(%rax)
movq %rbx, 0x48(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%r15)
leaq 0x4377e(%rip), %rdi     # 0x5f208
leaq 0x4377f(%rip), %rsi     # 0x5f210
movq %r15, %rdx
callq 0x29b2d
movq %rbp, %rdi
callq 0x2065a
testl %eax, %eax
je 0x1bab9
callq 0x1d928
movq %rax, 0x38(%r15)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1e6ec
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x1bae1
movq (%r13,%rbp,8), %rdi
callq 0x2065a
testl %eax, %eax
je 0x1badc
movq 0x38(%r15), %rdi
movq (%r13,%rbp,8), %rsi
callq 0x1e6ec
incq %rbp
jmp 0x1babb
xorl %r12d, %r12d
movq 0x40(%rsp), %r13
cmpq %r12, %r13
je 0x1bb1d
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x1bb04
movq (%rbx,%r12,8), %rax
movq 0x20(%rax), %rdi
callq 0x1bb2f
movq (%rbx,%r12,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1bb18
movq 0x38(%r15), %rcx
movq %rcx, (%rax)
incq %r12
jmp 0x1bae9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mklbl
Node *
mklbl(Srcloc loc, char *lbl)
{
	Node *n;

	assert(lbl != NULL);
	n = mknode(loc, Nlit);
	n->lit.littype = Llbl;
	n->lit.lblname = NULL;
	n->lit.lblval = strdup(lbl);
	return mkexpr(loc, Olit, n, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x1bbd0
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x9
popq %rsi
callq 0x1b610
movq %rax, %r15
movl $0x6, 0x18(%rax)
andq $0x0, 0x38(%rax)
movq %r14, %rdi
callq 0x4340
movq %rax, 0x30(%r15)
pushq $0x35
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1b718
leaq 0x172f9(%rip), %rdi     # 0x32ed0
leaq 0x172fe(%rip), %rsi     # 0x32edc
leaq 0x172fe(%rip), %rcx     # 0x32ee3
movl $0x116, %edx            # imm = 0x116
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: genlblstr
char *
genlblstr(char *buf, size_t sz, char *suffix)
{
	static int nextlbl;
	size_t len;

	len = snprintf(buf, 128, ".L%d%s", nextlbl++, suffix);
	assert(len <= sz);
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rsi, %r14
movq %rdi, %rbx
movl 0x42d56(%rip), %ecx     # 0x5e958
leal 0x1(%rcx), %eax
movl %eax, 0x42d4d(%rip)     # 0x5e958
leaq 0x172ed(%rip), %rdx     # 0x32eff
movl $0x80, %esi
xorl %eax, %eax
callq 0x4150
cltq
cmpq %r14, %rax
ja 0x1bc30
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x172cf(%rip), %rdi     # 0x32f06
leaq 0x1729e(%rip), %rsi     # 0x32edc
leaq 0x172cb(%rip), %rcx     # 0x32f10
movl $0x125, %edx            # imm = 0x125
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkstr
Node *
mkstr(Srcloc loc, Str val)
{
	Node *n;

	n = mknode(loc, Nlit);
	n->lit.littype = Lstr;
	n->lit.strval.len = val.len;
	n->lit.strval.buf = malloc(val.len);
	memcpy(n->lit.strval.buf, val.buf, val.len);

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x9
popq %rsi
callq 0x1b610
movq %rax, %r15
movl $0x4, 0x18(%rax)
movq %r14, 0x30(%rax)
movq %r14, %rdi
callq 0x4280
movq %rax, 0x38(%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4270
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkfloat
Node *
mkfloat(Srcloc loc, double val)
{
	Node *n;

	n = mknode(loc, Nlit);
	n->lit.littype = Lflt;
	n->lit.fltval = val;

	return n;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
pushq $0x9
popq %rsi
callq 0x1b610
movl $0x3, 0x18(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mknsname
Node *
mknsname(Srcloc loc, char *ns, char *name)
{
	Node *n;

	n = mknode(loc, Nname);
	if (ns)
		n->name.ns = strdup(ns);
	n->name.name = strdup(name);

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
pushq $0xa
popq %rsi
callq 0x1b610
movq %rax, %r14
testq %r15, %r15
je 0x1bd4a
movq %r15, %rdi
callq 0x4340
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkdecl
Node *
mkdecl(Srcloc loc, Node *name, Type *ty)
{
	Node *n;

	n = mknode(loc, Ndecl);
	n->decl.did = ndecls;
	n->decl.name = name;
	n->decl.type = ty;
	lappend(&decls, &ndecls, n);
	if (ty && hasparams(ty)) {
		n->decl.env = mkenv();
		bindtype(n->decl.env, ty);
	}

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
pushq $0xb
popq %rsi
callq 0x1b610
movq %rax, %r14
leaq 0x42be4(%rip), %rsi     # 0x5e960
movq 0x42bdd(%rip), %rax     # 0x5e960
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x42bd2(%rip), %rdi     # 0x5e968
movq %r14, %rdx
callq 0x29b2d
testq %rbx, %rbx
je 0x1bdc3
movq %rbx, %rdi
callq 0x2065a
testl %eax, %eax
je 0x1bdc3
callq 0x1d928
movq %rax, 0x38(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1e6ec
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: gentemp
Node *
gentemp(Srcloc loc, Type *ty, Node **dcl)
{
	char buf[128];
	static int nexttmp;
	Node *t, *r, *n;

	bprintf(buf, 128, ".t%d", nexttmp++);
	n = mkname(loc, buf);
	t = mkdecl(loc, n, ty);
	r = mkexpr(loc, Ovar, n, NULL);
	r->expr.type = t->decl.type;
	r->expr.did = t->decl.did;
	if (dcl)
		*dcl = t;
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x42b87(%rip), %ecx     # 0x5e970
leal 0x1(%rcx), %eax
movl %eax, 0x42b7e(%rip)     # 0x5e970
leaq 0x1713f(%rip), %rdx     # 0x32f38
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2a9bf
movq %r14, %rdi
movq %r12, %rsi
callq 0x1b7fd
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1bd5f
movq %rax, %r15
pushq $0x33
popq %rsi
movq %r14, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x38(%rax)
testq %rbx, %rbx
je 0x1be54
movq %r15, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/node.c
// Function: mkucon
Ucon *
mkucon(Srcloc loc, Node *name, Type *ut, Type *et)
{
	Ucon *uc;

	uc = zalloc(sizeof(Ucon));
	uc->loc = loc;
	uc->name = name;
	uc->utype = ut;
	uc->etype = et;
	return uc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %rdi
callq 0x29a78
movq %r12, (%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq