LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: needfreshenrec
static int
needfreshenrec(Type *t, Bitset *visited)
{
	size_t i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x46a23(%rip), %r15     # 0x621d0
testq %rdi, %rdi
je 0x1b7c6
movq (%r15), %rax
movq %rdi, %r14
movl 0x4(%rdi), %esi
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
jne 0x1b7b5
jmp 0x1b7d0
movl 0x4, %esi
xorl %r14d, %r14d
movq (%rbx), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x1b7f3
movq 0x8(%rbx), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jb 0x1b90e
movq %rbx, %rdi
callq 0x2d369
movl (%r14), %eax
cmpl $0x1c, %eax
jne 0x1b836
cmpq $0x0, 0x48(%r14)
je 0x1b82a
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1b79b
testl %eax, %eax
jne 0x1b852
incq %r12
cmpq 0x48(%r14), %r12
jb 0x1b80d
movq 0x68(%r14), %rax
movq (%rax), %rdi
jmp 0x1b7ad
addl $-0x17, %eax
cmpl $0x6, %eax
ja 0x1b8dc
leaq 0x1a2e3(%rip), %rcx     # 0x35b2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x78(%r14), %rcx
testq %rcx, %rcx
je 0x1b90e
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1b897
movq %rbx, %rsi
callq 0x1b79b
testl %eax, %eax
jne 0x1b852
movq 0x78(%r14), %rcx
incq %r15
xorl %eax, %eax
cmpq %rcx, %r15
jb 0x1b873
jmp 0x1b857
cmpq $0x0, 0x78(%r14)
je 0x1b90e
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e31c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b79b
testl %eax, %eax
jne 0x1b852
incq %r15
xorl %eax, %eax
cmpq 0x78(%r14), %r15
jb 0x1b8ad
jmp 0x1b857
cmpq $0x0, 0x70(%r14)
je 0x1b90e
xorl %r15d, %r15d
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1b79b
testl %eax, %eax
jne 0x1b852
incq %r15
xorl %eax, %eax
cmpq 0x70(%r14), %r15
jb 0x1b8e6
jmp 0x1b857
xorl %eax, %eax
jmp 0x1b857
// File: /workspace/github_c_makefile_star2_O3/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 0x1e31c
movq %rax, %rdi
callq 0x19640
movq %rax, %r14
cmpl $0x1d, (%rax)
jne 0x1b9a0
cmpb $0x0, 0x73(%rbx)
jne 0x1b9a0
xorl %edi, %edi
movq %r14, %rsi
callq 0x1b6e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e31c
movq %rax, %r15
movl (%r14), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x1b9a0
movl (%r15), %eax
addl $-0x1b, %eax
cmpl $0x1, %eax
ja 0x1b9a0
movq 0x48(%r14), %rax
cmpq 0x48(%r15), %rax
jne 0x1ba1b
testq %rax, %rax
je 0x1b9a0
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rsi
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdx
movq %rbx, %rdi
callq 0x1a38c
incq %r12
cmpq 0x48(%r14), %r12
jb 0x1b97f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c686
cmpq $0x0, 0x30(%rbx)
je 0x1b9f3
leaq 0x30(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1bd5b
movq %rbx, %rdi
callq 0x1b51f
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x1b51f
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a38c
cmpb $0x0, 0x72(%rbx)
je 0x1b9f3
movq (%r14), %rax
cmpl $0x0, 0x30(%rax)
je 0x1b9ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x19858
leaq 0x1a99a(%rip), %rsi     # 0x363a8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
movq %r14, %rdi
callq 0x2398e
movq %rax, %r14
movq %r15, %rdi
callq 0x2398e
movq %rax, %r15
movq %rbx, %rdi
callq 0x19858
leaq 0x1a987(%rip), %rsi     # 0x363c7
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: delayedcheck
static void
delayedcheck(Node *n)
{
	Postcheck *pc;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2ce79
movq %rax, %r14
movq %rbx, (%rax)
callq 0x1fdf7
movq %rax, 0x8(%r14)
callq 0x1fefd
movq %rax, 0x10(%r14)
leaq 0x45be3(%rip), %rdi     # 0x61928
leaq 0x45be4(%rip), %rsi     # 0x61930
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ceff
// File: /workspace/github_c_makefile_star2_O3/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 0x19640
movl 0x8(%rbx), %ecx
leal -0x8(%rcx), %edx
cmpl $0x5, %edx
jae 0x1c6cb
movl $0x1b, %esi
btl %edx, %esi
jae 0x1c6cb
movl %edx, %ecx
leaq 0x197e0(%rip), %rdx     # 0x35e90
movq (%rdx,%rcx,8), %rcx
movq %rax, (%rbx,%rcx)
cmpl $0x19, (%rax)
jne 0x1c6bf
popq %rbx
retq
movq (%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x1afe5
leaq 0x445ce(%rip), %rax     # 0x60ca0
movq (%rax,%rcx,8), %rsi
leaq 0x19d18(%rip), %rdi     # 0x363f5
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/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 0x1c7ca
movq %rsi, %r14
movq 0x50(%rbx), %r13
movq %rbx, %rdi
callq 0x1d422
cmpl $0x2a, %eax
jne 0x1c7ca
movq (%r13), %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0x1c7ca
movq (%r13), %rax
movq 0x50(%rax), %rax
movq (%rax), %r12
movq %r12, %rdi
callq 0x1e4eb
movq %rax, %rdi
callq 0x1ffef
testq %rax, %rax
je 0x1c7ca
movq %rax, %r15
callq 0x1fdf7
movq %rax, %rdi
movq %r12, %rsi
callq 0x20250
testq %rax, %rax
jne 0x1c7ca
movq %r12, %rdi
callq 0x1e4eb
movq %rax, %r12
movq 0x8(%r13), %rdi
callq 0x1e4eb
movq (%rbx), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1dfda
movq %rax, %r12
movq 0x8(%r13), %rsi
movq %r15, %rdi
callq 0x20250
testq %rax, %rax
je 0x1c7d7
movq %rax, %r15
movq (%rbx), %rdi
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r12
movq 0x48(%rbx), %rax
movq %rax, 0x48(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c9d3
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 0x19cc0(%rip), %rsi     # 0x364a8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: inferucon
static void
inferucon(Node *n, int *isconst)
{
	Ucon *uc;
	Type *t;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, (%rsi)
movq 0x50(%rdi), %r12
callq 0x1fdf7
movq (%r12), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x1c824
callq 0x1ffef
movq (%r12), %rsi
testq %rax, %rax
je 0x1c975
movq %rax, %rdi
callq 0x203fe
testq %rax, %rax
je 0x1c985
movq %rax, %r15
cmpq $0x0, 0x28(%rax)
movq 0x40(%rbx), %rax
je 0x1c86b
cmpq $0x2, %rax
je 0x1c875
movq (%r12), %rdi
callq 0x19858
leaq 0x19d1a(%rip), %rsi     # 0x36580
jmp 0x1c9c6
cmpq $0x2, %rax
jae 0x1c9b6
movq 0x20(%r15), %r12
cmpl $0x18, (%r12)
je 0x1c893
movq 0x68(%r12), %rax
movq (%rax), %r12
cmpl $0x18, (%r12)
jne 0x1c997
movq %r12, %rdi
callq 0x19640
movq %rax, %r13
callq 0x1e744
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1b68d
movq %rax, %r12
movq %rbp, %rdi
callq 0x1e785
movq %r12, %rdi
callq 0x227ac
movq 0x88(%rax), %rax
movq 0x8(%r15), %rcx
movq (%rax,%rcx,8), %r12
cmpq $0x0, 0x28(%r12)
je 0x1c91d
movq 0x50(%rbx), %rdi
addq $0x8, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1bd5b
movq 0x28(%r12), %r15
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x1b51f
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a38c
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, (%r14)
movq 0x20(%r12), %r14
cmpl $0x18, (%r14)
jne 0x1c95c
movq 0x8(%r14), %rdi
callq 0x22b29
movq %rax, %r15
movq 0x44f45(%rip), %rdi     # 0x61880
callq 0x2d180
movq %rax, 0x80(%r15)
movq 0x44e52(%rip), %rdi     # 0x617a0
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d71e
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c686
movq 0x18(%rsi), %rdx
leaq 0x19bac(%rip), %rsi     # 0x3652c
movq %rbx, %rdi
jmp 0x1c9cc
movq (%r12), %rdi
callq 0x19858
leaq 0x19ba8(%rip), %rsi     # 0x3653d
jmp 0x1c9c6
leaq 0x19b5d(%rip), %rdi     # 0x364fb
leaq 0x19913(%rip), %rsi     # 0x362b8
leaq 0x19b62(%rip), %rcx     # 0x3650e
movl $0x5e8, %edx            # imm = 0x5E8
callq 0x4180
movq (%r12), %rdi
callq 0x19858
leaq 0x19b90(%rip), %rsi     # 0x36556
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 0x1d422
cmpl $0x33, %eax
je 0x1cc88
movq %rbx, (%rsp)
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x1cc5c
movq 0x50(%r14), %r13
movl $0x1, %ebp
movq (%r13), %rdi
cmpl $0x8, 0x8(%rdi)
jne 0x1cc51
movq %r13, %rsi
callq 0x1c6e4
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1bd5b
testl %ebp, %ebp
je 0x1cc4f
movq (%r13), %rax
xorl %ebp, %ebp
cmpl $0x0, 0x30(%rax)
setne %bpl
jmp 0x1cc51
xorl %ebp, %ebp
addq $0x8, %r13
decq %rbx
jne 0x1cc1b
jmp 0x1cc61
movl $0x1, %ebp
movq %r14, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x43d2e(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
je 0x1cc7e
movl %ebp, 0x30(%r14)
jmp 0x1cc82
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_O3/oridb[P]mc/parse/infer.c
// Function: unifycall
static void
unifycall(Node *n)
{
	size_t i;
	Type *ft;

	ft = type(n->expr.args[0]);
	if (ft->type == Tyvar) {
		/* the first arg is the function itself, so it shouldn't be counted */
		ft = mktyfunc(n->loc, &n->expr.args[1], n->expr.nargs - 1, mktyvar(n->loc));
		unify(n, ft, type(n->expr.args[0]));
	} else if (tybase(ft)->type != Tyfunc) {
		fatal(n, "calling uncallable type %s", tystr(ft));
	}
	/* first arg: function itself */
	for (i = 1; i < n->expr.nargs; i++) {
		if (i == ft->nsub)
			fatal(n, "%s arity mismatch (expected %zd args, got %zd)",
					ctxstr(n->expr.args[0]), ft->nsub - 1, n->expr.nargs - 1);

		if (ft->sub[i]->type == Tyvalist) {
			break;
		}
		unify(n->expr.args[0], ft->sub[i], type(n->expr.args[i]));
	}
	if (i < ft->nsub && ft->sub[i]->type != Tyvalist)
		fatal(n, "%s arity mismatch (expected %zd args, got %zd)",
				ctxstr(n->expr.args[0]), ft->nsub - 1, i - 1);
	settype(n, ft->sub[0]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq (%rax), %rdi
callq 0x1b51f
cmpl $0x19, (%rax)
jne 0x1ccfb
movq 0x50(%rbx), %r14
addq $0x8, %r14
movq (%rbx), %rdi
movq 0x40(%rbx), %r15
decq %r15
callq 0x22b29
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x22d97
movq %rax, %r14
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x1b51f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1a38c
jmp 0x1cd0f
movq %rax, %r14
movq %rax, %rdi
callq 0x227ac
cmpl $0x13, (%rax)
jne 0x1cdad
movl $0x1, %r15d
cmpq $0x2, 0x40(%rbx)
jb 0x1cd58
cmpq 0x70(%r14), %r15
je 0x1cd7f
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %r12
cmpl $0x11, (%r12)
je 0x1cd58
movq 0x50(%rbx), %rax
movq (%rax), %r13
movq (%rax,%r15,8), %rdi
callq 0x1b51f
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a38c
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x1cd1c
movq 0x68(%r14), %rax
cmpq 0x70(%r14), %r15
jae 0x1cd6b
movq (%rax,%r15,8), %rcx
cmpl $0x11, (%rcx)
jne 0x1cdc9
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1c686
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x19858
movq 0x70(%r14), %rcx
decq %rcx
movq 0x40(%rbx), %r8
decq %r8
leaq 0x19915(%rip), %rsi     # 0x366b5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
movq %r14, %rdi
callq 0x2398e
leaq 0x198de(%rip), %rsi     # 0x3669a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x19858
movq 0x70(%r14), %rcx
decq %rcx
decq %r15
leaq 0x198cf(%rip), %rsi     # 0x366b5
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %r8
jmp 0x1cda6
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: infertuple
static void
infertuple(Node *n, int *isconst)
{
	Type **types;
	size_t i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, (%rsi)
movq 0x40(%rdi), %rdi
shlq $0x3, %rdi
callq 0x2ce79
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x1ce6c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x50(%rbx), %rdi
addq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x187ee
cmpl $0x0, 0x30(%rbx)
movq 0x50(%rbx), %rax
movl $0x0, %ecx
je 0x1ce4f
movq (%rax,%r13,8), %rdx
xorl %ecx, %ecx
cmpl $0x0, 0x30(%rdx)
setne %cl
movl %ecx, 0x30(%rbx)
movq (%rax,%r13,8), %rdi
callq 0x1b51f
movq %rax, (%r15,%r13,8)
incq %r13
addq $0x8, %r12
cmpq 0x40(%rbx), %r13
jb 0x1ce23
movl 0x30(%rbx), %eax
movl %eax, (%r14)
movq (%rbx), %rdi
movq 0x40(%rbx), %rdx
movq %r15, %rsi
callq 0x22d46
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1c686
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: inferstruct
static void
inferstruct(Node *n, int *isconst)
{
	size_t i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, (%rsi)
callq 0x1bd15
cmpq $0x0, 0x40(%rbx)
je 0x1ceed
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x50(%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x187ee
movq 0x50(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1cee0
movl $0x0, (%r14)
incq %r12
addq $0x8, %r15
cmpq 0x40(%rbx), %r12
jb 0x1cebb
movq (%rbx), %rdi
callq 0x22b29
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c686
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: inferarray
static void
inferarray(Node *n, int *isconst)
{
	size_t i;
	Type *t;
	Node *len;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, (%rsi)
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1cfb2
movq 0x50(%rbx), %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rcx
movq 0x48(%rcx), %rdi
testq %rdi, %rdi
je 0x1cf90
movl $0x1, %esi
callq 0x144db
movq (%r13,%rbp,8), %rcx
movq %rax, 0x48(%rcx)
movq (%r13,%rbp,8), %rax
movq 0x48(%rax), %r12
movq %r12, %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x1d055
movq 0x50(%r12), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
cmpl $0x2, %ecx
je 0x1cf95
testl %ecx, %ecx
jne 0x1d066
movl 0x30(%rax), %eax
jmp 0x1cf99
incq %r15
jmp 0x1cfa8
movq 0x30(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r15, %rax
cmovgeq %rcx, %r15
movq 0x40(%rbx), %rax
incq %rbp
cmpq %rax, %rbp
jb 0x1cf38
jmp 0x1cfb5
xorl %r15d, %r15d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1d57a
movq %rax, %r15
movq (%rbx), %rdi
callq 0x22b29
movq (%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x22c90
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x1d03c
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x50(%rbx), %rdi
addq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x187ee
movq 0x68(%r15), %rax
movq (%rax), %r12
movq 0x50(%rbx), %rax
movq (%rax,%rbp,8), %rdi
callq 0x1b51f
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a38c
movq 0x50(%rbx), %rax
movq (%rax,%rbp,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1d02f
movl $0x0, (%r14)
incq %rbp
addq $0x8, %r13
cmpq 0x40(%rbx), %rbp
jb 0x1cfe8
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c686
movq %r12, %rdi
callq 0x19858
leaq 0x19680(%rip), %rsi     # 0x366e4
jmp 0x1d075
movq %r12, %rdi
callq 0x19858
leaq 0x1969c(%rip), %rsi     # 0x36711
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: additerspecialization
static void
additerspecialization(Node *n, Stab *stab)
{
	Trait *tr;
	Type *ty;
	size_t i;

	tr = traittab[Tciter];
	ty = exprtype(n->iterstmt.seq);
	if (ty->type == Tyslice || ty->type == Tyarray || ty->type == Typtr)
		return;
	ty = tyfreshen(NULL, ty);
	for (i = 0; i < tr->nproto; i++) {
		ty = exprtype(n->iterstmt.seq);
		if (hthas(tr->proto[i]->decl.impls, ty))
			continue;
		lappend(&specializationscope, &nspecializationscope, stab);
		lappend(&specializations, &nspecializations, n);
		lappend(&genericdecls, &ngenericdecls, tr->proto[i]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4515e(%rip), %rax     # 0x621f8
movq (%rax), %rax
movq 0x30(%rax), %r13
movq 0x20(%rdi), %rdi
callq 0x1e384
movl (%rax), %ecx
cmpl $0x15, %ecx
ja 0x1d0ca
movl $0x340000, %edx         # imm = 0x340000
btl %ecx, %edx
jae 0x1d0ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
movq %rax, %rsi
callq 0x1b6e6
cmpq $0x0, 0x38(%r13)
je 0x1d0bb
xorl %ebp, %ebp
leaq 0x44834(%rip), %r15     # 0x61918
leaq 0x44835(%rip), %r12     # 0x61920
movq 0x20(%r14), %rdi
callq 0x1e384
movq 0x30(%r13), %rcx
movq (%rcx,%rbp,8), %rcx
movq 0x48(%rcx), %rdi
movq %rax, %rsi
callq 0x2da24
testl %eax, %eax
jne 0x1d14b
leaq 0x447e5(%rip), %rdi     # 0x618f8
leaq 0x447e6(%rip), %rsi     # 0x61900
movq %rbx, %rdx
callq 0x2ceff
leaq 0x447df(%rip), %rdi     # 0x61908
leaq 0x447e0(%rip), %rsi     # 0x61910
movq %r14, %rdx
callq 0x2ceff
movq 0x30(%r13), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ceff
incq %rbp
cmpq 0x38(%r13), %rbp
jb 0x1d0eb
jmp 0x1d0bb
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: verifyop
static void
verifyop(Node *n)
{
	Type *ty, *bty;
	Node *a;
	char *sa, *sb;
	size_t i, j;
	int found;

	ty = exprtype(n);
	bty = tybase(ty);
	switch (exprop(n)) {
	case Ostruct:
		if (bty->type != Tystruct)
			fatal(n, "wrong type for struct literal: %s\n", tystr(ty));
		for (i = 0; i < n->expr.nargs; i++) {
			found = 0;
			a = n->expr.args[i];
			for (j = 0; j < bty->nmemb; j++) {
				sa = namestr(a->expr.idx);
				sb = declname(bty->sdecls[j]);
				if (!strcmp(sa, sb))
					found = 1;
			}
			if (!found)
				fatal(n, "type %s has no member %s",
				    tystr(ty), namestr(a->expr.idx));
		}
		break;
	case Oarr:
		if (bty->type != Tyarray)
			fatal(n, "wrong type for struct literal: %s\n", tystr(ty));
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1e384
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x227ac
movq %rax, %r15
movq %rbx, %rdi
callq 0x1d422
cmpl $0x39, %eax
je 0x1d21c
cmpl $0x38, %eax
jne 0x1d222
cmpl $0x17, (%r15)
jne 0x1d260
cmpq $0x0, 0x40(%rbx)
je 0x1d222
movq 0x78(%r15), %rax
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
movq 0x50(%rbx), %rcx
movq (%rcx,%r13,8), %rbp
testq %rax, %rax
je 0x1d231
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x48(%rbp), %rdi
callq 0x1e4eb
movq %rax, %r12
movq 0x88(%r15), %rax
movq (%rax,%r14,8), %rdi
callq 0x1e2ed
movq %r12, %rdi
movq %rax, %rsi
callq 0x4230
movl $0x1, %ecx
testl %eax, %eax
je 0x1d1fa
movl %ebx, %ecx
incq %r14
movq 0x78(%r15), %rax
movl %ecx, %ebx
cmpq %rax, %r14
jb 0x1d1c8
testl %ecx, %ecx
je 0x1d231
incq %r13
movq 0x10(%rsp), %rbx
cmpq 0x40(%rbx), %r13
jb 0x1d1b6
jmp 0x1d222
cmpl $0x15, (%r15)
jne 0x1d260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
callq 0x2398e
movq %rax, %r14
movq 0x48(%rbp), %rdi
callq 0x1e4eb
leaq 0x197bd(%rip), %rsi     # 0x36a0b
movq 0x10(%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x138e7
movq 0x8(%rsp), %rdi
callq 0x2398e
leaq 0x19777(%rip), %rsi     # 0x369e8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 0x1e384
movq %rax, %r12
movq (%r15), %rdi
movq %rax, %rsi
callq 0x22d0e
movq %rax, %r14
movq %r12, %rdi
callq 0x1b043
testq %rax, %rax
je 0x1d301
movq (%r15), %rdi
movq %rax, %rsi
callq 0x22d0e
movq %rax, %r12
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x22d97
movq %rax, %rbx
leaq 0x68(%rax), %r15
leaq 0x70(%rax), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2ceff
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2ceff
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x2398e
leaq 0x197b7(%rip), %rdi     # 0x36ac7
movq %rax, %rsi
xorl %eax, %eax
callq 0x13844
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1fcd1
movq %rax, 0x98(%rbx)
xorl %edi, %edi
callq 0x1fcd1
movq %rax, 0x90(%rbx)
leaq 0x43f0b(%rip), %rcx     # 0x61278
movq 0x98(%rcx), %rcx
movq %rcx, (%rax)
leaq 0x10715(%rip), %rdi     # 0x2da93
leaq 0x107b6(%rip), %rsi     # 0x2db3b
callq 0x2d678
movq %rax, 0xa0(%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ceff
movq 0x98(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x249e1
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x1d3e5
movq %rdi, %rbx
movl $0x1, %esi
callq 0x144db
cmpl $0x8, 0x8(%rax)
jne 0x1d3e9
cmpl $0x35, 0x18(%rax)
jne 0x1d408
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0x1d411
movq 0x30(%rax), %rax
jmp 0x1d3e7
xorl %eax, %eax
popq %rbx
retq
leaq 0x13968(%rip), %rdi     # 0x30d58
leaq 0x19b15(%rip), %rsi     # 0x36f0c
leaq 0x19c62(%rip), %rcx     # 0x37060
movl $0x237, %edx            # imm = 0x237
callq 0x4180
leaq 0x19a8d(%rip), %rsi     # 0x36e9c
jmp 0x1d418
leaq 0x19aca(%rip), %rsi     # 0x36ee2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 0x2ce48
movq %rax, %r15
leaq 0x444de(%rip), %rsi     # 0x61948
movl 0x444d8(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl %ebx, 0x8(%r15)
movq %r14, (%r15)
leaq 0x444ce(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r12
leaq 0x44491(%rip), %rsi     # 0x61948
movl 0x4448b(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x7, 0x8(%r12)
movq %r15, (%r12)
leaq 0x4447a(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2ceff
movq %r14, %rdi
callq 0x4340
movq %rax, 0x20(%r12)
movl %ebx, 0x18(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d525
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d57a
movq %rax, %r15
testq %r12, %r12
jne 0x1d554
leaq 0x1b527(%rip), %rsi     # 0x38a58
movq %r14, %rdi
callq 0x1d6f5
movq %r14, %rdi
movl $0x2a, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r12
movq %r14, %rdi
movl $0x29, %esi
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 0x1d5e2
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x1d644
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)
movl $0x80, %edi
callq 0x2ce48
movq %rax, %rbx
leaq 0x442f0(%rip), %rsi     # 0x61948
movl 0x442ea(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbx)
movl $0x8, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x442de(%rip), %rdi     # 0x61950
movq %rbx, %rdx
callq 0x2ceff
movl %ebp, 0x18(%rbx)
movq %r15, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x50(%rbx), %r14
movq %rbx, %r15
addq $0x40, %r15
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1d6c1
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1d6cf
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1d6e4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ceff
jmp 0x1d6a8
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkname
Node *
mkname(Srcloc loc, char *name)
{
	Node *n;

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

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x44234(%rip), %rsi     # 0x61948
movl 0x4422e(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0xa, 0x8(%r15)
movq %r14, (%r15)
leaq 0x44220(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r12
leaq 0x441d4(%rip), %rsi     # 0x61948
movl 0x441ce(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x8, 0x8(%r12)
movq %r15, (%r12)
leaq 0x441bd(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2ceff
movl %ebp, 0x18(%r12)
movq %r14, 0x50(%r12)
movq %rbx, 0x40(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2d, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r15
testq %rbx, %rbx
je 0x1d804
leaq 0x50(%r15), %r12
movq %r15, %r13
addq $0x40, %r13
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2ceff
incq %rbp
cmpq %rbp, %rbx
jne 0x1d7ed
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_O3/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r13
leaq 0x44109(%rip), %rsi     # 0x61948
movl 0x44103(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x2, 0x8(%r13)
movq %r12, (%r13)
leaq 0x440f4(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2ceff
movq %r15, 0x18(%r13)
movq %r14, 0x20(%r13)
movq %rbx, 0x28(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x80, %edi
callq 0x2ce48
movq %rax, %rbp
leaq 0x4409d(%rip), %rsi     # 0x61948
movl 0x44097(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbp)
movl $0x3, 0x8(%rbp)
movq %r13, (%rbp)
leaq 0x4408a(%rip), %rdi     # 0x61950
movq %rbp, %rdx
callq 0x2ceff
movq %r12, 0x18(%rbp)
movq %r15, 0x20(%rbp)
movq %r14, 0x28(%rbp)
movq %rbx, 0x30(%rbp)
xorl %edi, %edi
callq 0x1fcd1
movq %rax, 0x38(%rbp)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkiterstmt
Node *
mkiterstmt(Srcloc loc, Node *elt, Node *seq, Node *body)
{
	Node *n;

	n = mknode(loc, Niterstmt);
	n->iterstmt.elt = elt;
	n->iterstmt.seq = seq;
	n->iterstmt.body = body;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r13
leaq 0x44024(%rip), %rsi     # 0x61948
movl 0x4401e(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x4, 0x8(%r13)
movq %r12, (%r13)
leaq 0x4400f(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2ceff
movq %r15, 0x18(%r13)
movq %r14, 0x20(%r13)
movq %rbx, 0x28(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r13
leaq 0x43fbd(%rip), %rsi     # 0x61948
movl 0x43fb7(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x5, 0x8(%r13)
movq %r12, (%r13)
leaq 0x43fa8(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2ceff
movq %r15, 0x18(%r13)
movq %r14, 0x28(%r13)
movq %rbx, 0x20(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r12
leaq 0x43f5a(%rip), %rsi     # 0x61948
movl 0x43f54(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x6, 0x8(%r12)
movq %r15, (%r12)
leaq 0x43f43(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2ceff
movq %r14, 0x18(%r12)
movq %rbx, 0x20(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movl $0x80, %edi
callq 0x2ce48
movq %rax, %rbx
leaq 0x43eec(%rip), %rsi     # 0x61948
movl 0x43ee6(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbx)
movl $0xc, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x43eda(%rip), %rdi     # 0x61950
movq %rbx, %rdx
callq 0x2ceff
movq %r12, 0x38(%rbx)
movq %r15, 0x30(%rbx)
movq %r13, 0x40(%rbx)
movl $0x1, %edi
callq 0x1fcd1
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x22d97
movq %rax, 0x28(%rbx)
callq 0x1fecc
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x20d76
testq %r15, %r15
je 0x1dae1
movq 0x18(%r13), %r13
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rsi
movq %r13, %rdi
callq 0x204de
incq %rbp
cmpq %rbp, %r15
jne 0x1dacd
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43e53(%rip), %rsi     # 0x61948
movl 0x43e4d(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43e3f(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movl $0x5, 0x18(%r15)
movq %rbx, 0x30(%r15)
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_O3/oridb[P]mc/parse/node.c
// Function: mkblock
Node *
mkblock(Srcloc loc, Stab *scope)
{
	Node *n;

	n = mknode(loc, Nblock);
	n->block.scope = scope;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43df2(%rip), %rsi     # 0x61948
movl 0x43dec(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x1, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43dde(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movq %rbx, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, (%rsp)
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43d8f(%rip), %rsi     # 0x61948
movl 0x43d89(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0xd, 0x8(%r15)
movq (%rsp), %rax
movq %rax, (%r15)
leaq 0x43d77(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movq %r14, 0x18(%r15)
movq %rbp, 0x28(%r15)
movq %r13, 0x30(%r15)
movq %r12, 0x40(%r15)
movq %rbx, 0x48(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%r15)
leaq 0x44603(%rip), %rdi     # 0x62208
leaq 0x44604(%rip), %rsi     # 0x62210
movq %r15, %rdx
callq 0x2ceff
movq %rbp, %rdi
callq 0x231e7
testl %eax, %eax
je 0x1dc34
callq 0x1fecc
movq %rax, 0x38(%r15)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20d76
testq %r12, %r12
je 0x1dc5f
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rdi
callq 0x231e7
testl %eax, %eax
je 0x1dc57
movq 0x38(%r15), %rdi
movq (%r13,%rbp,8), %rsi
callq 0x20d76
incq %rbp
cmpq %rbp, %r12
jne 0x1dc3b
movq 0x40(%rsp), %r13
testq %r13, %r13
je 0x1dc9e
xorl %r12d, %r12d
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x1dc82
movq (%rbx,%r12,8), %rax
movq 0x20(%rax), %rdi
callq 0x1dcb0
movq (%rbx,%r12,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1dc96
movq 0x38(%r15), %rcx
movq %rcx, (%rax)
incq %r12
cmpq %r12, %r13
jne 0x1dc6c
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_O3/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 0x1dd84
movq %rsi, %r14
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43c1d(%rip), %rsi     # 0x61948
movl 0x43c17(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %rbx, (%r15)
leaq 0x43c09(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movl $0x6, 0x18(%r15)
movq $0x0, 0x38(%r15)
movq %r14, %rdi
callq 0x4340
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movl $0x35, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1d5e2
leaq 0x19175(%rip), %rdi     # 0x36f00
leaq 0x1917a(%rip), %rsi     # 0x36f0c
leaq 0x1917a(%rip), %rcx     # 0x36f13
movl $0x116, %edx            # imm = 0x116
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/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 0x43ba2(%rip), %ecx     # 0x61958
leal 0x1(%rcx), %eax
movl %eax, 0x43b99(%rip)     # 0x61958
leaq 0x19169(%rip), %rdx     # 0x36f2f
movl $0x80, %esi
xorl %eax, %eax
callq 0x4150
cltq
cmpq %r14, %rax
ja 0x1dde4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1914b(%rip), %rdi     # 0x36f36
leaq 0x1911a(%rip), %rsi     # 0x36f0c
leaq 0x19147(%rip), %rcx     # 0x36f40
movl $0x125, %edx            # imm = 0x125
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r12
leaq 0x43ae6(%rip), %rsi     # 0x61948
movl 0x43ae0(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x9, 0x8(%r12)
movq %r15, (%r12)
leaq 0x43acf(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2ceff
movl $0x4, 0x18(%r12)
movq %r14, 0x30(%r12)
movq %r14, %rdi
callq 0x4280
movq %rax, 0x38(%r12)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4270
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkint
Node *
mkint(Srcloc loc, uvlong val)
{
	Node *n;

	n = mknode(loc, Nlit);
	n->lit.littype = Lint;
	n->lit.intval = val;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43a68(%rip), %rsi     # 0x61948
movl 0x43a62(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43a54(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movl $0x2, 0x18(%r15)
movq %rbx, 0x30(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkchar
Node *
mkchar(Srcloc loc, uint32_t val)
{
	Node *n;

	n = mknode(loc, Nlit);
	n->lit.littype = Lchr;
	n->lit.chrval = val;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r15
leaq 0x43a11(%rip), %rsi     # 0x61948
movl 0x43a0b(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x439fd(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2ceff
movl $0x0, 0x18(%r15)
movl %ebx, 0x30(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r14
leaq 0x439b8(%rip), %rsi     # 0x61948
movl 0x439b2(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0x9, 0x8(%r14)
movq %rbx, (%r14)
leaq 0x439a4(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2ceff
movl $0x3, 0x18(%r14)
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r14
leaq 0x43949(%rip), %rsi     # 0x61948
movl 0x43943(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0xa, 0x8(%r14)
movq %r12, (%r14)
leaq 0x43935(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2ceff
testq %r15, %r15
je 0x1e034
movq %r15, %rdi
callq 0x4340
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq