LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4f239(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x30340
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x14, (%rax)
je 0x2eb0e
movq -0x20(%rbp), %rax
cmpl $0x15, (%rax)
je 0x2eb0e
movq -0x20(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x2eb13
jmp 0x2ebd5
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2ae70
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x2ebd5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x30340
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x2eb73
jmp 0x2ebc4
movq -0x10(%rbp), %rdx
leaq 0x4e89a(%rip), %rdi     # 0x7d418
leaq 0x4e89b(%rip), %rsi     # 0x7d420
callq 0x48290
movq -0x8(%rbp), %rdx
leaq 0x4e893(%rip), %rdi     # 0x7d428
leaq 0x4e894(%rip), %rsi     # 0x7d430
callq 0x48290
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x4e880(%rip), %rdi     # 0x7d438
leaq 0x4e881(%rip), %rsi     # 0x7d440
callq 0x48290
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2eb2c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/infer.c
// Function: adddispspecialization
static void
adddispspecialization(Node *n, Stab *stab)
{
	Trait *tr;
	Type *ty;

	tr = traittab[Tcdisp];
	ty = exprtype(n);
	assert(tr->nproto == 1);
	if (hthas(tr->proto[0]->decl.impls, ty))
		return;
	lappend(&specializationscope, &nspecializationscope, stab);
	lappend(&specializations, &nspecializations, n);
	lappend(&genericdecls, &ngenericdecls, tr->proto[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4f119(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30340
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, 0x38(%rax)
jne 0x2ec1c
jmp 0x2ec3b
leaq 0x23d58(%rip), %rdi     # 0x5297b
leaq 0x23606(%rip), %rsi     # 0x52230
movl $0x113, %edx            # imm = 0x113
leaq 0x23d55(%rip), %rcx     # 0x5298b
callq 0x6160
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x2ec5a
jmp 0x2eca6
movq -0x10(%rbp), %rdx
leaq 0x4e7b3(%rip), %rdi     # 0x7d418
leaq 0x4e7b4(%rip), %rsi     # 0x7d420
callq 0x48290
movq -0x8(%rbp), %rdx
leaq 0x4e7ac(%rip), %rdi     # 0x7d428
leaq 0x4e7ad(%rip), %rsi     # 0x7d430
callq 0x48290
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdx
leaq 0x4e79e(%rip), %rdi     # 0x7d438
leaq 0x4e79f(%rip), %rsi     # 0x7d440
callq 0x48290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30340
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, -0x48(%rbp)
subl $0x38, %eax
je 0x2ecfc
jmp 0x2eceb
movl -0x48(%rbp), %eax
subl $0x39, %eax
je 0x2ee22
jmp 0x2ee53
movq -0x18(%rbp), %rax
cmpl $0x17, (%rax)
je 0x2ed2b
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x23c92(%rip), %rsi     # 0x529b6
movb $0x0, %al
callq 0x1dfe0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2ee20
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2edcc
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x30600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x2edbc
movl $0x1, -0x44(%rbp)
jmp 0x2edbe
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2ed68
cmpl $0x0, -0x44(%rbp)
jne 0x2ee0d
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x30600
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
leaq 0x23bd3(%rip), %rsi     # 0x529d9
movb $0x0, %al
callq 0x1dfe0
jmp 0x2ee0f
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2ed33
jmp 0x2ee55
movq -0x18(%rbp), %rax
cmpl $0x15, (%rax)
je 0x2ee51
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x23b6c(%rip), %rsi     # 0x529b6
movb $0x0, %al
callq 0x1dfe0
jmp 0x2ee55
jmp 0x2ee55
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a8f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jb 0x2ef15
movq -0x10(%rbp), %rax
cmpl $0x8, (%rax)
ja 0x2ef15
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
leaq 0x22dfe(%rip), %rcx     # 0x51cb0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jl 0x2eede
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
leaq 0x22ddf(%rip), %rcx     # 0x51cb0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jle 0x2ef10
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x23ae9(%rip), %rsi     # 0x529f2
movb $0x0, %al
callq 0x1dfe0
jmp 0x2efb1
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jb 0x2ef27
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jbe 0x2ef30
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x2efaf
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
leaq 0x22df1(%rip), %rcx     # 0x51d40
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jb 0x2ef7b
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
leaq 0x22dd2(%rip), %rcx     # 0x51d40
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2efad
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rax, %rcx
leaq 0x23a7a(%rip), %rsi     # 0x52a20
movb $0x0, %al
callq 0x1dfe0
jmp 0x2efaf
jmp 0x2efb1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30340
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rsi
movq (%rax), %rdi
callq 0x37430
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x297f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2f01f
movq -0x18(%rbp), %rdi
callq 0x38a10
movq %rax, %rsi
leaq 0x23a7d(%rip), %rdi     # 0x52a95
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rsi
movq (%rax), %rdi
callq 0x37430
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x37520
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq -0x38(%rbp), %rsi
addq $0x70, %rsi
movq -0x28(%rbp), %rdx
callq 0x48290
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq -0x38(%rbp), %rsi
addq $0x70, %rsi
movq -0x30(%rbp), %rdx
callq 0x48290
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xa8, %edx
callq 0x6180
xorl %edi, %edi
callq 0x32b90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
xorl %edi, %edi
callq 0x32b90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
leaq 0x4dc87(%rip), %rax     # 0x7cd98
movq 0x98(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rcx, (%rax)
leaq 0x1a6b3(%rip), %rdi     # 0x497e0
leaq 0x1a87c(%rip), %rsi     # 0x499b0
callq 0x48fe0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x3a3d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f19d
movq $0x0, -0x8(%rbp)
jmp 0x2f206
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1f390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x2f1cf
movq -0x10(%rbp), %rdi
leaq 0x23ca0(%rip), %rsi     # 0x52e68
movb $0x0, %al
callq 0x1dfe0
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x18(%rax)
je 0x2f1fa
movq -0x10(%rbp), %rdi
leaq 0x23cbb(%rip), %rsi     # 0x52eae
movb $0x0, %al
callq 0x1dfe0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x80, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq 0x4e1e4(%rip), %rax     # 0x7d468
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdx
leaq 0x4e1c3(%rip), %rdi     # 0x7d470
leaq 0x4e1b4(%rip), %rsi     # 0x7d468
callq 0x48290
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x2f260
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f350
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f3c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2f38f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x25c0e(%rip), %rsi     # 0x54f78
callq 0x2f540
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rdi
movl $0x29, %esi
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x2f400
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x2f43b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x2f260
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x2f4d9
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x2f4f6
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2f530
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
addq $0x28, %rsi
movq -0x38(%rbp), %rdx
callq 0x48290
jmp 0x2f49e
movq -0x18(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x2f260
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2f65d
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
addq $0x38, %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x48290
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2f61c
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2f260
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x2f260
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
xorl %edi, %edi
callq 0x32b90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x2f260
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0xc, %esi
callq 0x2f260
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, %edi
callq 0x32b90
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdi
callq 0x37520
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x32ee0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x348e0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2f94d
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33970
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2f920
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x5, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0xd, %esi
callq 0x2f260
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rdx
leaq 0x4e2d7(%rip), %rdi     # 0x7dd20
leaq 0x4e2d8(%rip), %rsi     # 0x7dd28
callq 0x48290
movq -0x18(%rbp), %rdi
callq 0x37ce0
cmpl $0x0, %eax
je 0x2fa84
callq 0x32ee0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x348e0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x2fad5
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x37ce0
cmpl $0x0, %eax
je 0x2fac5
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x348e0
jmp 0x2fac7
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2fa8c
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq 0x10(%rbp), %rax
jae 0x2fb4d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2fb0f
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2fb60
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x38(%rax)
je 0x2fb3d
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
jmp 0x2fb3f
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2fadd
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fbf9
jmp 0x2fc18
leaq 0x232cc(%rip), %rdi     # 0x52ecc
leaq 0x232d1(%rip), %rsi     # 0x52ed8
movl $0x116, %edx            # imm = 0x116
leaq 0x232cc(%rip), %rcx     # 0x52edf
callq 0x6160
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x4, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rdi
callq 0x6280
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6260
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x2f260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x2f260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ff01
movq -0x10(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xb, %esi
callq 0x2f260
movq %rax, -0x20(%rbp)
movq 0x4d533(%rip), %rcx     # 0x7d480
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdx
leaq 0x4d510(%rip), %rdi     # 0x7d488
leaq 0x4d501(%rip), %rsi     # 0x7d480
callq 0x48290
cmpq $0x0, -0x18(%rbp)
je 0x2ffba
movq -0x18(%rbp), %rdi
callq 0x37ce0
cmpl $0x0, %eax
je 0x2ffba
callq 0x32ee0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x348e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movl 0x4d49c(%rip), %ecx     # 0x7d490
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x4d491(%rip)     # 0x7d490
movl $0x80, %esi
leaq 0x22f29(%rip), %rdx     # 0x52f34
movb $0x0, %al
callq 0x4a230
leaq -0xa0(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x2f540
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rdi
callq 0x2ff20
movq %rax, -0xa8(%rbp)
movq -0xb8(%rbp), %rdx
movq -0x8(%rbp), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x300a7
movq -0xa8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x30, %edi
callq 0x48160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdi
callq 0x30120
movq %rax, %rdx
movq -0x8(%rbp), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: nodetype
Type *
nodetype(Node *n)
{
	switch (n->type) {
	case Ndecl:	return n->decl.type;	break;
	case Nexpr:	return n->expr.type;	break;
	case Nlit:	return n->lit.type;	break;
	default: die("Node %s has no type", nodestr[n->type]); break;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x8, %eax
je 0x302ef
jmp 0x302cd
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x302fd
jmp 0x302d7
movl -0x14(%rbp), %eax
subl $0xb, %eax
jne 0x3030b
jmp 0x302e1
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3032d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3032d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3032d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x4c4a5(%rip), %rax     # 0x7c7c0
movq (%rax,%rcx,8), %rsi
leaq 0x22c69(%rip), %rdi     # 0x52f8f
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: litvaleq
int
litvaleq(Node *a, Node *b)
{
	assert(a->type == Nlit && b->type == Nlit);
	if (a->lit.littype != b->lit.littype)
		return 0;
	switch (a->lit.littype) {
	case Lvoid:	return 1;
	case Lchr:	return a->lit.chrval == b->lit.chrval;
	case Lbool:	return a->lit.boolval == b->lit.boolval;
	case Lint:	return a->lit.intval == b->lit.intval;
	case Lflt:	return a->lit.fltval == b->lit.fltval;
	case Lstr:
			return a->lit.strval.len == b->lit.strval.len &&
				!memcmp(a->lit.strval.buf, b->lit.strval.buf, a->lit.strval.len);
	case Lfunc:	return a->lit.fnval == b->lit.fnval;
	case Llbl:	return !strcmp(a->lit.lblval, b->lit.lblval);	break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x30416
movq -0x18(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0x30416
jmp 0x30435
leaq 0x22b86(%rip), %rdi     # 0x52fa3
leaq 0x22ab4(%rip), %rsi     # 0x52ed8
movl $0x204, %edx            # imm = 0x204
leaq 0x22b96(%rip), %rcx     # 0x52fc6
callq 0x6160
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x30451
movl $0x0, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x30599
movq -0x20(%rbp), %rax
leaq 0x229d7(%rip), %rcx     # 0x52e48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x30(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq 0x30(%rdx), %rcx
movb %al, -0x21(%rbp)
jne 0x30548
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x61f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x6220
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x305a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: namestr
char *
namestr(Node *name)
{
	if (!name)
		return "";
	assert(name->type == Nname);
	return name->name.name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30620
leaq 0x2520b(%rip), %rax     # 0x55825
movq %rax, -0x8(%rbp)
jmp 0x30657
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0x3062c
jmp 0x3064b
leaq 0x22a0b(%rip), %rdi     # 0x5303e
leaq 0x2289e(%rip), %rsi     # 0x52ed8
movl $0x240, %edx            # imm = 0x240
leaq 0x22a0c(%rip), %rcx     # 0x53052
callq 0x6160
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: nameeq
int
nameeq(void *p1, void *p2)
{
	Node *a, *b;
	a = p1;
	b = p2;
	if (a == b)
		return 1;

	return streq(namestr(a), namestr(b)) && streq(a->name.ns, b->name.ns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x306a3
movl $0x1, -0x4(%rbp)
jmp 0x306fa
movq -0x20(%rbp), %rdi
callq 0x30600
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30600
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x499b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x306ef
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x499b0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: lblstr
char *
lblstr(Node *n)
{
	assert(exprop(n) == Olit);
	assert(n->expr.args[0]->type == Nlit);
	assert(n->expr.args[0]->lit.littype == Llbl);
	return n->expr.args[0]->lit.lblval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
jne 0x3072c
jmp 0x3074b
leaq 0x22935(%rip), %rdi     # 0x53068
leaq 0x2279e(%rip), %rsi     # 0x52ed8
movl $0x247, %edx            # imm = 0x247
leaq 0x22934(%rip), %rcx     # 0x5307a
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x3075e
jmp 0x3077d
leaq 0x2292a(%rip), %rdi     # 0x5308f
leaq 0x2276c(%rip), %rsi     # 0x52ed8
movl $0x248, %edx            # imm = 0x248
leaq 0x22902(%rip), %rcx     # 0x5307a
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x6, 0x18(%rax)
jne 0x30790
jmp 0x307af
leaq 0x22916(%rip), %rdi     # 0x530ad
leaq 0x2273a(%rip), %rsi     # 0x52ed8
movl $0x249, %edx            # imm = 0x249
leaq 0x228d0(%rip), %rcx     # 0x5307a
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/node.c
// Function: did
static size_t
did(Node *n)
{
	if (n->type == Ndecl) {
		return n->decl.did;
	} else if (n->type == Nexpr) {
		assert(exprop(n) == Ovar);
		return n->expr.did;
	}
	dumpn(n, stderr);
	die("Can't get did");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
jne 0x30824
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3088e
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x3086b
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
jne 0x3083e
jmp 0x3085d
leaq 0x2288d(%rip), %rdi     # 0x530d2
leaq 0x2268c(%rip), %rsi     # 0x52ed8
movl $0x253, %edx            # imm = 0x253
leaq 0x2288c(%rip), %rcx     # 0x530e4
callq 0x6160
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3088e
jmp 0x3086d
movq -0x10(%rbp), %rdi
movq 0x2e778(%rip), %rax     # 0x5eff0
movq (%rax), %rsi
callq 0x1de90
leaq 0x22870(%rip), %rdi     # 0x530f7
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: substget
Type *
substget(Tysubst *subst, Type *from)
{
	Type *t;
	size_t i;

	t = NULL;
	for (i = subst->nsubst; i > 0; i--) {
		t = htget(subst->subst[i-1], from);
		if (t)
			break;
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x30984
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x30974
jmp 0x30984
jmp 0x30976
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x30944
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: substfree
void
substfree(Tysubst *subst)
{
	size_t i;

	for (i = 0; i < subst->nsubst; i++)
		htfree(subst->subst[i]);
	lfree(&subst->subst, &subst->nsubst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x30a54
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x490a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x30a24
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x48580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: genericname
Node *
genericname(Node *n, Type *param, Type *t)
{
	char buf[1024];
	char *p;
	char *end;
	Node *name;

	if (!n->decl.isgeneric)
		return n->decl.name;
	p = buf;
	end = buf + sizeof buf;
	p += bprintf(p, end - p, "%s", n->decl.name->name.name);
	if (param) {
		p += bprintf(p, end - p, "$");
		p += tyidfmt(p, end - p, param);
	}
	p += bprintf(p, end - p, "$");
	p += tyidfmt(p, end - p, t);
	name = mkname(n->loc, buf);
	if (n->decl.name->name.ns)
		setns(name, n->decl.name->name.ns);
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x73(%rax)
jne 0x319f2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x31b6d
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, -0x430(%rbp)
movq -0x428(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rax
subq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x2105c(%rip), %rdx     # 0x52a9b
movb $0x0, %al
callq 0x4a230
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x31abe
movq -0x428(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rax
subq %rax, %rsi
leaq 0x197ff(%rip), %rdx     # 0x4b279
movb $0x0, %al
callq 0x4a230
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x393e0
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rax
subq %rax, %rsi
leaq 0x1979c(%rip), %rdx     # 0x4b279
movb $0x0, %al
callq 0x4a230
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rax
subq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x393e0
addq -0x428(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x10(%rbp), %rax
leaq -0x420(%rbp), %rsi
movq (%rax), %rdi
callq 0x2f540
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x31b62
movq -0x438(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x2fb60
movq -0x438(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw (%rax,%rax)