LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x20037
movq (%r12), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x1c9f9
callq 0x2022f
movq (%r12), %rsi
testq %rax, %rax
je 0x1cb3e
movq %rax, %rdi
callq 0x2063c
testq %rax, %rax
je 0x1cb4e
movq %rax, %r15
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x1ca33
cmpq $0x2, 0x40(%rbx)
jae 0x1cb91
testq %rax, %rax
je 0x1ca3e
cmpq $0x2, 0x40(%rbx)
jne 0x1cb7f
movq 0x20(%r15), %r12
cmpl $0x18, (%r12)
je 0x1ca51
movq 0x68(%r12), %rax
movq (%rax), %r12
cmpl $0x18, (%r12)
jne 0x1cb60
movq %r12, %rdi
callq 0x196c0
movq %rax, %r13
callq 0x1e994
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1b84a
movq %rax, %r12
movq %rbp, %rdi
callq 0x1e9d5
movq %r12, %rdi
callq 0x22c44
movq 0x88(%rax), %rax
movq 0x8(%r15), %rcx
movq (%rax,%rcx,8), %r12
cmpq $0x0, 0x28(%r12)
je 0x1cae6
movq 0x50(%rbx), %rdi
addq $0x8, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1bf13
movq 0x28(%r12), %r15
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x1b6e6
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a59b
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, (%r14)
movq 0x20(%r12), %r14
cmpl $0x18, (%r14)
jne 0x1cb25
movq 0x8(%r14), %rdi
callq 0x22fd7
movq %rax, %r15
movq 0x44d7c(%rip), %rdi     # 0x61880
callq 0x2d680
movq %rax, 0x80(%r15)
movq 0x44c89(%rip), %rdi     # 0x617a0
movq %r15, %rsi
movq %r14, %rdx
callq 0x2dbc2
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 0x1c85b
movq 0x18(%rsi), %rdx
leaq 0x199d3(%rip), %rsi     # 0x3651c
movq %rbx, %rdi
jmp 0x1cba7
movq (%r12), %rdi
callq 0x19a6f
leaq 0x199cf(%rip), %rsi     # 0x3652d
jmp 0x1cba1
leaq 0x19984(%rip), %rdi     # 0x364eb
leaq 0x1973a(%rip), %rsi     # 0x362a8
leaq 0x19989(%rip), %rcx     # 0x364fe
movl $0x5e8, %edx            # imm = 0x5E8
callq 0x4180
movq (%r12), %rdi
callq 0x19a6f
leaq 0x199e1(%rip), %rsi     # 0x36570
jmp 0x1cba1
movq (%r12), %rdi
callq 0x19a6f
leaq 0x199a5(%rip), %rsi     # 0x36546
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: 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 0x1d672
cmpl $0x33, %eax
je 0x1ce41
movq %rbx, (%rsp)
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x1ce17
movq 0x50(%r14), %r13
movl $0x1, %ebp
movq (%r13), %rdi
cmpl $0x8, 0x8(%rdi)
jne 0x1ce0c
movq %r13, %rsi
callq 0x1c8b9
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1bf13
testl %ebp, %ebp
je 0x1ce0a
movq (%r13), %rax
xorl %ebp, %ebp
cmpl $0x0, 0x30(%rax)
setne %bpl
jmp 0x1ce0c
xorl %ebp, %ebp
addq $0x8, %r13
decq %rbx
jne 0x1cdd6
jmp 0x1ce1c
movl $0x1, %ebp
movq %r14, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x43b73(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
je 0x1ce37
movl %ebp, 0x30(%r14)
movl 0x30(%r14), %eax
movq (%rsp), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: 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 0x1b6e6
cmpl $0x19, (%rax)
jne 0x1ceb4
movq 0x50(%rbx), %r14
addq $0x8, %r14
movq (%rbx), %rdi
movq 0x40(%rbx), %r15
decq %r15
callq 0x22fd7
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x23245
movq %rax, %r14
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x1b6e6
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1a59b
jmp 0x1cec8
movq %rax, %r14
movq %rax, %rdi
callq 0x22c44
cmpl $0x13, (%rax)
jne 0x1cf6a
movl $0x1, %r15d
cmpq $0x2, 0x40(%rbx)
jb 0x1cf11
cmpq 0x70(%r14), %r15
je 0x1cf3c
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %r12
cmpl $0x11, (%r12)
je 0x1cf11
movq 0x50(%rbx), %rax
movq (%rax), %r13
movq (%rax,%r15,8), %rdi
callq 0x1b6e6
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a59b
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x1ced5
cmpq 0x70(%r14), %r15
jae 0x1cf24
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x11, (%rax)
jne 0x1cf86
movq 0x68(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1c85b
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x19a6f
movq 0x70(%r14), %rcx
decq %rcx
movq 0x40(%rbx), %r8
decq %r8
leaq 0x19748(%rip), %rsi     # 0x366a5
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
movq %r14, %rdi
callq 0x23e44
leaq 0x19711(%rip), %rsi     # 0x3668a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
movq 0x50(%rbx), %rax
movq (%rax), %rdi
callq 0x19a6f
movq 0x70(%r14), %rcx
decq %rcx
decq %r15
leaq 0x19702(%rip), %rsi     # 0x366a5
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %r8
jmp 0x1cf63
// File: /workspace/github_c_makefile_star2_O1/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 0x2d379
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x1d02d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x50(%rbx), %rdi
addq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x188e1
cmpl $0x0, 0x30(%rbx)
movl $0x0, %eax
je 0x1d00c
movq 0x50(%rbx), %rax
movq (%rax,%r13,8), %rcx
xorl %eax, %eax
cmpl $0x0, 0x30(%rcx)
setne %al
movl %eax, 0x30(%rbx)
movq 0x50(%rbx), %rax
movq (%rax,%r13,8), %rdi
callq 0x1b6e6
movq %rax, (%r15,%r13,8)
incq %r13
addq $0x8, %r12
cmpq 0x40(%rbx), %r13
jb 0x1cfe0
movl 0x30(%rbx), %eax
movl %eax, (%r14)
movq (%rbx), %rdi
movq 0x40(%rbx), %rdx
movq %r15, %rsi
callq 0x231f4
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1c85b
// File: /workspace/github_c_makefile_star2_O1/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 0x1becd
cmpq $0x0, 0x40(%rbx)
je 0x1d0ae
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x50(%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x188e1
movq 0x50(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1d0a1
movl $0x0, (%r14)
incq %r12
addq $0x8, %r15
cmpq 0x40(%rbx), %r12
jb 0x1d07c
movq (%rbx), %rdi
callq 0x22fd7
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c85b
// File: /workspace/github_c_makefile_star2_O1/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)
cmpq $0x0, 0x40(%rdi)
je 0x1d16e
movq 0x50(%rbx), %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rax
movq 0x48(%rax), %rdi
testq %rdi, %rdi
je 0x1d14f
movl $0x1, %esi
callq 0x14703
movq (%r13,%rbp,8), %rcx
movq %rax, 0x48(%rcx)
movq (%r13,%rbp,8), %rax
movq 0x48(%rax), %r12
movq %r12, %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x1d211
movq 0x50(%r12), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
cmpl $0x2, %ecx
je 0x1d154
testl %ecx, %ecx
jne 0x1d222
movl 0x30(%rax), %eax
jmp 0x1d158
incq %r15
jmp 0x1d163
movq 0x30(%rax), %rax
leaq 0x1(%rax), %rcx
cmpq %r15, %rax
cmovgeq %rcx, %r15
incq %rbp
cmpq 0x40(%rbx), %rbp
jb 0x1d0f7
jmp 0x1d171
xorl %r15d, %r15d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1d7ca
movq %rax, %r15
movq (%rbx), %rdi
callq 0x22fd7
movq (%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2313e
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x1d1f8
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x50(%rbx), %rdi
addq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x188e1
movq 0x68(%r15), %rax
movq (%rax), %r12
movq 0x50(%rbx), %rax
movq (%rax,%rbp,8), %rdi
callq 0x1b6e6
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a59b
movq 0x50(%rbx), %rax
movq (%rax,%rbp,8), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1d1eb
movl $0x0, (%r14)
incq %rbp
addq $0x8, %r13
cmpq 0x40(%rbx), %rbp
jb 0x1d1a4
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c85b
movq %r12, %rdi
callq 0x19a6f
leaq 0x194b4(%rip), %rsi     # 0x366d4
jmp 0x1d231
movq %r12, %rdi
callq 0x19a6f
leaq 0x194d0(%rip), %rsi     # 0x36701
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x44fa2(%rip), %rax     # 0x621f8
movq (%rax), %rax
movq 0x30(%rax), %r13
movq 0x20(%rdi), %rdi
callq 0x1e5d4
movl (%rax), %ecx
cmpl $0x15, %ecx
ja 0x1d286
movl $0x340000, %edx         # imm = 0x340000
btl %ecx, %edx
jae 0x1d286
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
movq %rax, %rsi
callq 0x1b8a3
cmpq $0x0, 0x38(%r13)
je 0x1d277
xorl %ebp, %ebp
leaq 0x44678(%rip), %r15     # 0x61918
leaq 0x44679(%rip), %r12     # 0x61920
movq 0x20(%r14), %rdi
callq 0x1e5d4
movq 0x30(%r13), %rcx
movq (%rcx,%rbp,8), %rcx
movq 0x48(%rcx), %rdi
movq %rax, %rsi
callq 0x2decd
testl %eax, %eax
jne 0x1d307
leaq 0x44629(%rip), %rdi     # 0x618f8
leaq 0x4462a(%rip), %rsi     # 0x61900
movq %rbx, %rdx
callq 0x2d3ff
leaq 0x44623(%rip), %rdi     # 0x61908
leaq 0x44624(%rip), %rsi     # 0x61910
movq %r14, %rdx
callq 0x2d3ff
movq 0x30(%r13), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d3ff
incq %rbp
cmpq 0x38(%r13), %rbp
jb 0x1d2a7
jmp 0x1d277
// File: /workspace/github_c_makefile_star2_O1/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 0x1e5d4
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x22c44
movq %rax, %r15
movq %rbx, %rdi
callq 0x1d672
cmpl $0x39, %eax
je 0x1d3d3
cmpl $0x38, %eax
jne 0x1d3d9
cmpl $0x17, (%r15)
jne 0x1d417
cmpq $0x0, 0x40(%rbx)
je 0x1d3d9
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
movq 0x50(%rbx), %rax
movq (%rax,%r13,8), %rbp
cmpq $0x0, 0x78(%r15)
je 0x1d3e8
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x48(%rbp), %rdi
callq 0x1e73b
movq %rax, %r12
movq 0x88(%r15), %rax
movq (%rax,%r14,8), %rdi
callq 0x1e53d
movq %r12, %rdi
movq %rax, %rsi
callq 0x4230
movl $0x1, %ecx
testl %eax, %eax
je 0x1d3b4
movl %ebx, %ecx
incq %r14
movl %ecx, %ebx
cmpq 0x78(%r15), %r14
jb 0x1d382
testl %ecx, %ecx
je 0x1d3e8
incq %r13
movq 0x10(%rsp), %rbx
cmpq 0x40(%rbx), %r13
jb 0x1d36e
jmp 0x1d3d9
cmpl $0x15, (%r15)
jne 0x1d417
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
callq 0x23e44
movq %rax, %r14
movq 0x48(%rbp), %rdi
callq 0x1e73b
leaq 0x195f6(%rip), %rsi     # 0x369fb
movq 0x10(%rsp), %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x13aa3
movq 0x8(%rsp), %rdi
callq 0x23e44
leaq 0x195b0(%rip), %rsi     # 0x369d8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/infer.c
// Function: checkrange
static void
checkrange(Node *n)
{
	Type *t;
	int64_t sval;
	uint64_t uval;
	static const int64_t svranges[][2] = {
		/* signed ints; allow one above max range for unary -'ve operator */
		[Tyint8]  = {-128LL, 128LL},
		[Tyint16] = {-32768LL, 32768LL},
		[Tyint32] = {-2147483648LL, 2147483648LL},
		[Tyint]	  = {-2147483648LL, 2147483648LL},
		[Tyint64] = {-9223372036854775808ULL, 9223372036854775807ULL},
	};

	static const uint64_t uvranges[][2] = {
		[Tybyte]   = {0, 255ULL},
		[Tyuint8]  = {0, 255ULL},
		[Tyuint16] = {0, 65535ULL},
		[Tyuint]   = {0, 4294967295ULL},
		[Tyuint32] = {0, 4294967295ULL},
		[Tyuint64] = {0, 18446744073709551615ULL},
		[Tychar]   = {0, 4294967295ULL},
	};

	/* signed types */
	t = type(n);
	if (t->type >= Tyint8 && t->type <= Tyint64) {
		sval = n->lit.intval;
		if (sval < svranges[t->type][0] || sval > svranges[t->type][1])
			fatal(n, "literal value %lld out of range for type \"%s\"", sval, tystr(t));
	} else if ((t->type >= Tybyte && t->type <= Tyuint64) || t->type == Tychar) {
		uval = n->lit.intval;
		if (uval < uvranges[t->type][0] || uval > uvranges[t->type][1])
			fatal(n, "literal value %llu out of range for type \"%s\"", uval, tystr(t));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b6e6
movl (%rax), %ecx
leal -0x4(%rcx), %edx
cmpl $0x4, %edx
ja 0x1d47a
movq 0x30(%rbx), %r14
shlq $0x4, %rcx
leaq 0x188a6(%rip), %rdx     # 0x35d00
cmpq (%rcx,%rdx), %r14
jl 0x1d469
addq %rcx, %rdx
cmpq 0x8(%rdx), %r14
jle 0x1d4a0
movq %rax, %rdi
callq 0x23e44
leaq 0x1959c(%rip), %rsi     # 0x36a14
jmp 0x1d4be
leal -0x9(%rcx), %edx
cmpl $0x6, %edx
jae 0x1d4a8
movq 0x30(%rbx), %r14
shlq $0x4, %rcx
leaq 0x188ff(%rip), %rdx     # 0x35d90
cmpq (%rcx,%rdx), %r14
jb 0x1d4af
addq %rcx, %rdx
cmpq 0x8(%rdx), %r14
ja 0x1d4af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x3, %ecx
je 0x1d482
jmp 0x1d4a0
movq %rax, %rdi
callq 0x23e44
leaq 0x19584(%rip), %rsi     # 0x36a42
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x1e5d4
movq %rax, %r12
movq (%r15), %rdi
movq %rax, %rsi
callq 0x231bc
movq %rax, %r14
movq %r12, %rdi
callq 0x1b20a
testq %rax, %rax
je 0x1d551
movq (%r15), %rdi
movq %rax, %rsi
callq 0x231bc
movq %rax, %r12
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x23245
movq %rax, %rbx
leaq 0x68(%rax), %r15
leaq 0x70(%rax), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2d3ff
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2d3ff
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x23e44
leaq 0x19557(%rip), %rdi     # 0x36ab7
movq %rax, %rsi
xorl %eax, %eax
callq 0x13a00
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1ff11
movq %rax, 0x98(%rbx)
xorl %edi, %edi
callq 0x1ff11
movq %rax, 0x90(%rbx)
leaq 0x43cbb(%rip), %rcx     # 0x61278
movq 0x98(%rcx), %rcx
movq %rcx, (%rax)
leaq 0x1096e(%rip), %rdi     # 0x2df3c
leaq 0x10a05(%rip), %rsi     # 0x2dfda
callq 0x2db1c
movq %rax, 0xa0(%rbx)
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d3ff
movq 0x98(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e59
// File: /workspace/github_c_makefile_star2_O1/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 0x1d635
movq %rdi, %rbx
movl $0x1, %esi
callq 0x14703
cmpl $0x8, 0x8(%rax)
jne 0x1d639
cmpl $0x35, 0x18(%rax)
jne 0x1d658
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0x1d661
movq 0x30(%rax), %rax
jmp 0x1d637
xorl %eax, %eax
popq %rbx
retq
leaq 0x13708(%rip), %rdi     # 0x30d48
leaq 0x198b5(%rip), %rsi     # 0x36efc
leaq 0x19a02(%rip), %rcx     # 0x37050
movl $0x237, %edx            # imm = 0x237
callq 0x4180
leaq 0x1982d(%rip), %rsi     # 0x36e8c
jmp 0x1d668
leaq 0x1986a(%rip), %rsi     # 0x36ed2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r15
leaq 0x4428e(%rip), %rsi     # 0x61948
movl 0x44288(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl %ebx, 0x8(%r15)
movq %r14, (%r15)
leaq 0x4427e(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r12
leaq 0x44241(%rip), %rsi     # 0x61948
movl 0x4423b(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x7, 0x8(%r12)
movq %r15, (%r12)
leaq 0x4422a(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2d3ff
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_O1/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 0x1d775
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d7ca
movq %rax, %r15
testq %r12, %r12
jne 0x1d7a4
leaq 0x1b307(%rip), %rsi     # 0x38a88
movq %r14, %rdi
callq 0x1d945
movq %r14, %rdi
movl $0x2a, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
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 0x1d832
// File: /workspace/github_c_makefile_star2_O1/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 0x1d894
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 0x2d348
movq %rax, %rbx
leaq 0x440a0(%rip), %rsi     # 0x61948
movl 0x4409a(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbx)
movl $0x8, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x4408e(%rip), %rdi     # 0x61950
movq %rbx, %rdx
callq 0x2d3ff
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 0x1d911
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1d91f
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1d934
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d3ff
jmp 0x1d8f8
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r15
leaq 0x43fe4(%rip), %rsi     # 0x61948
movl 0x43fde(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0xa, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43fd0(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r12
leaq 0x43f84(%rip), %rsi     # 0x61948
movl 0x43f7e(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x8, 0x8(%r12)
movq %r15, (%r12)
leaq 0x43f6d(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2d3ff
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_O1/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 0x1d832
movq %rax, %r15
testq %rbx, %rbx
je 0x1da54
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 0x2d3ff
incq %rbp
cmpq %rbp, %rbx
jne 0x1da3d
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_O1/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 0x2d348
movq %rax, %r13
leaq 0x43eb9(%rip), %rsi     # 0x61948
movl 0x43eb3(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x2, 0x8(%r13)
movq %r12, (%r13)
leaq 0x43ea4(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %rbp
leaq 0x43e4d(%rip), %rsi     # 0x61948
movl 0x43e47(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbp)
movl $0x3, 0x8(%rbp)
movq %r13, (%rbp)
leaq 0x43e3a(%rip), %rdi     # 0x61950
movq %rbp, %rdx
callq 0x2d3ff
movq %r12, 0x18(%rbp)
movq %r15, 0x20(%rbp)
movq %r14, 0x28(%rbp)
movq %rbx, 0x30(%rbp)
xorl %edi, %edi
callq 0x1ff11
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_O1/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 0x2d348
movq %rax, %r13
leaq 0x43dd4(%rip), %rsi     # 0x61948
movl 0x43dce(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x4, 0x8(%r13)
movq %r12, (%r13)
leaq 0x43dbf(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r13
leaq 0x43d6d(%rip), %rsi     # 0x61948
movl 0x43d67(%rip), %eax     # 0x61948
movl %eax, 0xc(%r13)
movl $0x5, 0x8(%r13)
movq %r12, (%r13)
leaq 0x43d58(%rip), %rdi     # 0x61950
movq %r13, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r12
leaq 0x43d0a(%rip), %rsi     # 0x61948
movl 0x43d04(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x6, 0x8(%r12)
movq %r15, (%r12)
leaq 0x43cf3(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %rbx
leaq 0x43c9c(%rip), %rsi     # 0x61948
movl 0x43c96(%rip), %eax     # 0x61948
movl %eax, 0xc(%rbx)
movl $0xc, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x43c8a(%rip), %rdi     # 0x61950
movq %rbx, %rdx
callq 0x2d3ff
movq %r12, 0x38(%rbx)
movq %r15, 0x30(%rbx)
movq %r13, 0x40(%rbx)
movl $0x1, %edi
callq 0x1ff11
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x23245
movq %rax, 0x28(%rbx)
callq 0x2010c
movq %rax, 0x18(%rbx)
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x20ffe
testq %r15, %r15
je 0x1dd31
movq 0x18(%r13), %r13
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rsi
movq %r13, %rdi
callq 0x2071e
incq %rbp
cmpq %rbp, %r15
jne 0x1dd1d
movl $0x80, %edi
callq 0x2d348
movq %rax, %r15
leaq 0x43c03(%rip), %rsi     # 0x61948
movl 0x43bfd(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43bef(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r15
leaq 0x43ba2(%rip), %rsi     # 0x61948
movl 0x43b9c(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x1, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43b8e(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
movq %rbx, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r15
leaq 0x43b3f(%rip), %rsi     # 0x61948
movl 0x43b39(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0xd, 0x8(%r15)
movq (%rsp), %rax
movq %rax, (%r15)
leaq 0x43b27(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
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 0x443b3(%rip), %rdi     # 0x62208
leaq 0x443b4(%rip), %rsi     # 0x62210
movq %r15, %rdx
callq 0x2d3ff
movq %rbp, %rdi
callq 0x23690
testl %eax, %eax
je 0x1de84
callq 0x2010c
movq %rax, 0x38(%r15)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20ffe
testq %r12, %r12
je 0x1deaf
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rdi
callq 0x23690
testl %eax, %eax
je 0x1dea7
movq 0x38(%r15), %rdi
movq (%r13,%rbp,8), %rsi
callq 0x20ffe
incq %rbp
cmpq %rbp, %r12
jne 0x1de8b
movq 0x40(%rsp), %r13
testq %r13, %r13
je 0x1deee
xorl %r12d, %r12d
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x1ded2
movq (%rbx,%r12,8), %rax
movq 0x20(%rax), %rdi
callq 0x1df00
movq (%rbx,%r12,8), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x1dee6
movq 0x38(%r15), %rcx
movq %rcx, (%rax)
incq %r12
cmpq %r12, %r13
jne 0x1debc
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_O1/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 0x1dfd4
movq %rsi, %r14
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2d348
movq %rax, %r15
leaq 0x439cd(%rip), %rsi     # 0x61948
movl 0x439c7(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %rbx, (%r15)
leaq 0x439b9(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
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 0x1d832
leaq 0x18f15(%rip), %rdi     # 0x36ef0
leaq 0x18f1a(%rip), %rsi     # 0x36efc
leaq 0x18f1a(%rip), %rcx     # 0x36f03
movl $0x116, %edx            # imm = 0x116
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x43952(%rip), %ecx     # 0x61958
leal 0x1(%rcx), %eax
movl %eax, 0x43949(%rip)     # 0x61958
leaq 0x18f09(%rip), %rdx     # 0x36f1f
movl $0x80, %esi
xorl %eax, %eax
callq 0x4150
cltq
cmpq %r14, %rax
ja 0x1e034
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18eeb(%rip), %rdi     # 0x36f26
leaq 0x18eba(%rip), %rsi     # 0x36efc
leaq 0x18ee7(%rip), %rcx     # 0x36f30
movl $0x125, %edx            # imm = 0x125
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r12
leaq 0x43896(%rip), %rsi     # 0x61948
movl 0x43890(%rip), %eax     # 0x61948
movl %eax, 0xc(%r12)
movl $0x9, 0x8(%r12)
movq %r15, (%r12)
leaq 0x4387f(%rip), %rdi     # 0x61950
movq %r12, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r15
leaq 0x43818(%rip), %rsi     # 0x61948
movl 0x43812(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x43804(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
movl $0x2, 0x18(%r15)
movq %rbx, 0x30(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r15
leaq 0x437c1(%rip), %rsi     # 0x61948
movl 0x437bb(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x437ad(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
movl $0x0, 0x18(%r15)
movl %ebx, 0x30(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r14
leaq 0x43768(%rip), %rsi     # 0x61948
movl 0x43762(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0x9, 0x8(%r14)
movq %rbx, (%r14)
leaq 0x43754(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %r14
leaq 0x436f9(%rip), %rsi     # 0x61948
movl 0x436f3(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0xa, 0x8(%r14)
movq %r12, (%r14)
leaq 0x436e5(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2d3ff
testq %r15, %r15
je 0x1e284
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
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2d348
movq %rax, %r14
leaq 0x43684(%rip), %rsi     # 0x61948
movl 0x4367e(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0xb, 0x8(%r14)
movq %r12, (%r14)
leaq 0x43670(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2d3ff
leaq 0x43671(%rip), %rsi     # 0x61960
movq 0x4366a(%rip), %rax     # 0x61960
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x4365f(%rip), %rdi     # 0x61968
movq %r14, %rdx
callq 0x2d3ff
testq %rbx, %rbx
je 0x1e336
movq %rbx, %rdi
callq 0x23690
testl %eax, %eax
je 0x1e336
callq 0x2010c
movq %rax, 0x38(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20ffe
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4360e(%rip), %ecx     # 0x61970
leal 0x1(%rcx), %eax
movl %eax, 0x43605(%rip)     # 0x61970
leaq 0x18be6(%rip), %rdx     # 0x36f58
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2e42e
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d945
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e29f
movq %rax, %r15
movq %r14, %rdi
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x38(%rax)
testq %rbx, %rbx
je 0x1e3cf
movq %r15, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x30, %edi
callq 0x2d348
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
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/node.c
// Function: mkbool
Node *
mkbool(Srcloc loc, int val)
{
	Node *n;

	n = mknode(loc, Nlit);
	n->lit.littype = Lbool;
	n->lit.boolval = val;

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x80, %edi
callq 0x2d348
movq %rax, %r15
leaq 0x43513(%rip), %rsi     # 0x61948
movl 0x4350d(%rip), %eax     # 0x61948
movl %eax, 0xc(%r15)
movl $0x9, 0x8(%r15)
movq %r14, (%r15)
leaq 0x434ff(%rip), %rdi     # 0x61950
movq %r15, %rdx
callq 0x2d3ff
movl $0x1, 0x18(%r15)
movl %ebx, 0x30(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/node.c
// Function: mkboollit
Node *
mkboollit(Srcloc loc, int val) {
	Node *e;

	e = mkexpr(loc, Olit, mkbool(loc, val), NULL);
	e->expr.type = mktype(loc, Tybool);
	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2d348
movq %rax, %r14
leaq 0x434bd(%rip), %rsi     # 0x61948
movl 0x434b7(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0x9, 0x8(%r14)
movq %rbx, (%r14)
leaq 0x434a9(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2d3ff
movl $0x1, 0x18(%r14)
movl %ebp, 0x30(%r14)
movq %rbx, %rdi
movl $0x35, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22d38
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/node.c
// Function: mkvoid
Node *
mkvoid(Srcloc loc)
{
	Node *n;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2d348
movq %rax, %r14
leaq 0x43442(%rip), %rsi     # 0x61948
movl 0x4343c(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0x9, 0x8(%r14)
movq %rbx, (%r14)
leaq 0x4342e(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2d3ff
movl $0x7, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/node.c
// Function: declname
char *
declname(Node *n)
{
	Node *name;
	assert(n->type == Ndecl);
	name = n->decl.name;
	return name->name.name;
}

// Assembly:
cmpl $0xb, 0x8(%rdi)
jne 0x1e54c
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rax
retq
pushq %rax
leaq 0x18a09(%rip), %rdi     # 0x36f5d
leaq 0x189a1(%rip), %rsi     # 0x36efc
leaq 0x18a0c(%rip), %rcx     # 0x36f6e
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x4180