LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: namedesc
Blob *
namedesc(Type *ty)
{
	Blob **sub;
	size_t nsub;

	sub = NULL;
	nsub = 0;
	lappend(&sub, &nsub, mkblobi(Bti8, Tyname));
	namevec(&sub, &nsub, ty->name);
	lappend(&sub, &nsub, tydescsub(ty->sub[0]));
	return mkblobseq(sub, nsub);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rsp, %r14
movq %rax, (%r14)
movl $0x1c, %esi
xorl %edi, %edi
callq 0x491c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2ceff
movq 0x88(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11d8e
movq 0x68(%r15), %rax
movq (%rax), %rdi
callq 0x11e64
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2ceff
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x497f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: tydescblob
Blob *
tydescblob(Type *ty)
{
	char buf[512];
	Blob *b, *sz, *sub;

	if (ty->type == Tyname && hasparams(ty))
		return NULL;

	if (ty->type == Tyname) {
		b = mkblobseq(NULL, 0);
		sz = mkblobi(Btimin, 0);
		sub = namedesc(ty);
		sz->ival = blobsz(sub);
		lappend(&b->seq.sub, &b->seq.nsub, sz);
		lappend(&b->seq.sub, &b->seq.nsub, sub);
		if (ty->vis != Visintern)
			b->isglobl = 1;
	} else {
		b = tydescsub(ty);
	}
	tydescid(buf, sizeof buf, ty);
	b->lbl = strdup(buf);
	return b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
cmpl $0x1c, (%rdi)
jne 0x123e2
movq %rbx, %rdi
callq 0x231e7
testl %eax, %eax
je 0x12377
xorl %r14d, %r14d
jmp 0x1240c
cmpl $0x1c, (%rbx)
jne 0x123e2
xorl %edi, %edi
xorl %esi, %esi
callq 0x497f
movq %rax, %r14
movl $0x4, %edi
xorl %esi, %esi
callq 0x491c
movq %rax, %r15
movq %rbx, %rdi
callq 0x122d3
movq %rax, %r12
movq %rax, %rdi
callq 0x11cc4
movq %rax, 0x20(%r15)
leaq 0x20(%r14), %r13
movq %r14, %rbp
addq $0x28, %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2ceff
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2ceff
cmpl $0x0, 0x10(%rbx)
je 0x123ed
movb $0x1, 0x18(%r14)
jmp 0x123ed
movq %rbx, %rdi
callq 0x11e64
movq %rax, %r14
movq %rsp, %r15
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movq %rbx, %rdx
callq 0x579f
movq %r15, %rdi
callq 0x4340
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: tyalign
size_t
tyalign(Type *ty)
{
	size_t align, i;

	align = 1;
	ty = tybase(ty);
	switch (ty->type) {
	case Tyarray:
		align = tyalign(ty->sub[0]);
		break;
	case Tytuple:
		for (i = 0; i < ty->nsub; i++)
			align = max(align, tyalign(ty->sub[i]));
		break;
	case Tyunion:
		align = 4;
		for (i = 0; i < ty->nmemb; i++)
			if (ty->udecls[i]->etype)
				align = max(align, tyalign(ty->udecls[i]->etype));
		break;
	case Tystruct:
		for (i = 0; i < ty->nmemb; i++)
			align = max(align, tyalign(decltype(ty->sdecls[i])));
		break;
	case Tyslice:
		align = 8;
		break;
	default:
		align = max(align, tysize(ty));
	}
	return min(align, Ptrsz);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x227ac
movq %rax, %rbx
movl (%rax), %eax
addl $-0x14, %eax
cmpl $0x4, %eax
ja 0x12784
leaq 0x201cb(%rip), %rcx     # 0x32864
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %r14d
jmp 0x127a4
movq 0x78(%rbx), %rax
movl $0x4, %r14d
testq %rax, %rax
je 0x127a4
xorl %r15d, %r15d
movq 0x88(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq 0x28(%rcx), %rdi
testq %rdi, %rdi
je 0x126ee
callq 0x12677
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e201
movq %rax, %r14
movq 0x78(%rbx), %rax
incq %r15
cmpq %rax, %r15
jb 0x126c3
jmp 0x127a4
cmpq $0x0, 0x70(%rbx)
je 0x1279e
movl $0x1, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x12677
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e201
movq %rax, %r14
incq %r15
cmpq 0x70(%rbx), %r15
jb 0x1270f
jmp 0x127a4
cmpq $0x0, 0x78(%rbx)
je 0x1279e
movl $0x1, %r14d
xorl %r15d, %r15d
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e31c
movq %rax, %rdi
callq 0x12677
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e201
movq %rax, %r14
incq %r15
cmpq 0x78(%rbx), %r15
jb 0x12745
jmp 0x127a4
movq 0x68(%rbx), %rax
movq (%rax), %rdi
callq 0x12677
jmp 0x12799
movq %rbx, %rdi
callq 0x12421
movl $0x1, %edi
movq %rax, %rsi
callq 0x2e201
movq %rax, %r14
jmp 0x127a4
movl $0x1, %r14d
movl $0x8, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2e20c
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: tyoffset
ssize_t
tyoffset(Type *ty, Node *memb)
{
	size_t i;
	size_t off;

	ty = tybase(ty);
	if (ty->type == Typtr)
		ty = tybase(ty->sub[0]);

	switch (memb->type) {
	case Nname:
		assert(ty->type == Tystruct);
		off = 0;
		for (i = 0; i < ty->nmemb; i++) {
			off = alignto(off, decltype(ty->sdecls[i]));
			if (!strcmp(namestr(memb), declname(ty->sdecls[i])))
				return off;
			off += size(ty->sdecls[i]);
		}
		die("bad offset");
		return 0;
	case Nlit:
		assert(ty->type == Tytuple);
		assert(memb->lit.intval < ty->nsub);
		off = 0;
		for (i = 0; i < memb->lit.intval; i++) {
			off += tysize(ty->sub[i]);
			off = alignto(off, ty->sub[i+1]);
		}
		return off;
	default:
		die("bad offset node type");
		return 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
callq 0x227ac
movq %rax, %r14
cmpl $0x12, (%rax)
jne 0x127de
movq 0x68(%r14), %rax
movq (%rax), %rdi
callq 0x227ac
movq %rax, %r14
movl 0x8(%rbx), %eax
cmpl $0x9, %eax
je 0x12891
cmpl $0xa, %eax
jne 0x128ea
cmpl $0x17, (%r14)
jne 0x128f3
cmpq $0x0, 0x78(%r14)
je 0x12883
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e31c
movq %r12, %rdi
movq %rax, %rsi
callq 0xec3c
movq %rax, %r15
movq %rbx, %rdi
callq 0x1e4eb
movq %rax, %r12
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e2ed
movq %r12, %rdi
movq %rax, %rsi
callq 0x4230
testl %eax, %eax
je 0x128dd
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rax
xorl %ecx, %ecx
cmpl $0x8, 0x8(%rax)
setne %cl
movq 0x20(%rax,%rcx,8), %rdi
callq 0x12421
movq %rax, %r12
addq %r15, %r12
incq %r13
cmpq 0x78(%r14), %r13
jb 0x1280a
leaq 0x201e0(%rip), %rdi     # 0x32a6a
xorl %eax, %eax
callq 0x13844
cmpl $0x16, (%r14)
jne 0x12912
movq 0x30(%rbx), %rax
cmpq 0x70(%r14), %rax
jae 0x12931
xorl %r15d, %r15d
testq %rax, %rax
je 0x128dd
xorl %r12d, %r12d
movq 0x68(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x12421
addq %rax, %r15
movq 0x68(%r14), %rax
movq 0x8(%rax,%r12,8), %rsi
incq %r12
movq %r15, %rdi
callq 0xec3c
movq %rax, %r15
cmpq 0x30(%rbx), %r12
jb 0x128b0
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x201b4(%rip), %rdi     # 0x32aa5
jmp 0x1288a
leaq 0x2013a(%rip), %rdi     # 0x32a34
leaq 0x2005b(%rip), %rsi     # 0x3295c
leaq 0x20141(%rip), %rcx     # 0x32a49
movl $0x170, %edx            # imm = 0x170
callq 0x4180
leaq 0x2015c(%rip), %rdi     # 0x32a75
leaq 0x2003c(%rip), %rsi     # 0x3295c
leaq 0x20122(%rip), %rcx     # 0x32a49
movl $0x17b, %edx            # imm = 0x17B
callq 0x4180
leaq 0x20151(%rip), %rdi     # 0x32a89
leaq 0x2001d(%rip), %rsi     # 0x3295c
leaq 0x20103(%rip), %rcx     # 0x32a49
movl $0x17c, %edx            # imm = 0x17C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: countargs
size_t
countargs(Type *t)
{
	size_t nargs;

	t = tybase(t);
	nargs = t->nsub - 1;
	if (classify(t->sub[0]) == ArgBig)
		nargs++;
	/* valists are replaced with hidden type parameter,
	 * which we want on the stack for ease of ABI */
	if (tybase(t->sub[t->nsub - 1])->type == Tyvalist)
		nargs--;
	return nargs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x227ac
movq %rax, %r14
movq 0x68(%rax), %rax
movq 0x70(%r14), %rbx
movq (%rax), %rdi
callq 0x129b4
xorl %ecx, %ecx
cmpl $0x8, %eax
setne %cl
subq %rcx, %rbx
movq 0x68(%r14), %rax
movq 0x70(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdi
callq 0x227ac
xorl %ecx, %ecx
cmpl $0x11, (%rax)
sete %cl
subq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: classify
ArgType
classify(Type *t)
{
	size_t sz = tysize(t);
	size_t total_offset = 0;

	/* p must be of length exactly 2 */
	PassIn pi[2] = { PassInNoPref, PassInNoPref };

	if (tybase(t)->type == Tyvoid) {
		return ArgVoid;
	} else if (isstacktype(t)) {
		if (isaggregate(t) && sz <= 16) {
			classify_recursive(t, pi, &total_offset);
			if (pi[0] == PassInMemory || pi[1] == PassInMemory) {
				return ArgBig;
			}

			switch(pi[0]) {
			case PassInInt:
				if (sz <= 8) {
					return ArgAggrI;
				}
				switch(pi[1]) {
				case PassInInt: return ArgAggrII;
				case PassInSSE: return ArgAggrIF;
				default:
					die("Impossible return from classify_recursive");
					break;
				}
				break;
			case PassInSSE:
				if (sz <= 8) {
					return ArgAggrF;
				}
				switch(pi[1]) {
				case PassInInt: return ArgAggrFI;
				case PassInSSE: return ArgAggrFF;
				default:
					die("Impossible return from classify_recursive");
					break;
				}
				break;
			default:
				die("Impossible return from classify_recursive");
				break;
			}
		}

		return ArgBig;
	}

	return ArgReg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
callq 0x12421
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movq %r15, %rdi
callq 0x227ac
cmpl $0x1, (%rax)
je 0x12a79
movq %r15, %rdi
callq 0x22784
testl %eax, %eax
je 0x12a73
movq %r15, %rdi
callq 0x12aba
testl %eax, %eax
setne %al
cmpq $0x11, %rbx
setb %cl
andb %al, %cl
movl $0x8, %r14d
cmpb $0x1, %cl
jne 0x12a79
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12aeb
movl (%r12), %ecx
movl 0x4(%r12), %eax
cmpl $0x3, %ecx
sete %dl
cmpl $0x3, %eax
sete %sil
orb %dl, %sil
jne 0x12a79
cmpl $0x1, %ecx
je 0x12a88
cmpl $0x2, %ecx
jne 0x12aac
movl $0x2, %r14d
cmpq $0x9, %rbx
jb 0x12a79
movl $0x4, %r14d
cmpl $0x2, %eax
je 0x12a79
cmpl $0x1, %eax
jne 0x12aac
movl $0x6, %r14d
jmp 0x12a79
movl $0x1, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x3, %r14d
cmpq $0x9, %rbx
jb 0x12a79
movl $0x5, %r14d
cmpl $0x2, %eax
je 0x12a79
cmpl $0x1, %eax
jne 0x12aac
movl $0x7, %r14d
jmp 0x12a79
leaq 0x20007(%rip), %rdi     # 0x32aba
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/dump.c
// Function: dumpfilestabs
void
dumpfilestabs(int depth, FILE *fd)
{
	size_t nk, i;
	void **k;

	k = htkeys(file.ns, &nk);
	for (i = 0; i < nk; i++)
		outstab(htget(file.ns, k[i]), fd, depth);
	free(k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4e228(%rip), %r12     # 0x61278
movq 0xa0(%r12), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2da36
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x13099
xorl %r15d, %r15d
movq 0xa0(%r12), %rdi
movq (%r14,%r15,8), %rsi
callq 0x2d8fa
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x12de1
incq %r15
cmpq 0x8(%rsp), %r15
jb 0x13071
movq %r14, %rdi
callq 0x4040
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/dump.c
// Function: dump
void
dump(FILE *fd)
{
	size_t i;

	fprintf(fd, "(name = %s)\n", file.files[0]);
	dumpfilestabs(1, fd);
	for (i = 0; i < file.nuses; i++)
		outnode(file.uses[i], fd, 1);
	for (i = 0; i < file.nstmts; i++)
		outnode(file.stmts[i], fd, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4e1bb(%rip), %r14     # 0x61278
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x1fabd(%rip), %rsi     # 0x32b88
xorl %eax, %eax
callq 0x4240
movl $0x1, %edi
movq %rbx, %rsi
callq 0x13038
cmpq $0x0, 0x18(%r14)
je 0x13107
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x13135
incq %r15
cmpq 0x18(%r14), %r15
jb 0x130e9
cmpq $0x0, 0x48(%r14)
je 0x1312f
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x13135
incq %r15
cmpq 0x48(%r14), %r15
jb 0x13111
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/err.c
// Function: lfatalv
void
lfatalv(Srcloc l, char *msg, va_list ap)
{
	fprintf(stdout, "%s:%d: ", fname(l), lnum(l));
	vfprintf(stdout, msg, ap);
	fprintf(stdout, "\n");
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3064f(%rip), %rbp     # 0x43fd0
movq (%rbp), %r12
callq 0x1d31c
movq %rax, %r13
movq %r15, %rdi
callq 0x1d330
leaq 0x1f3f8(%rip), %rsi     # 0x32d94
movq %r12, %rdi
movq %r13, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x4240
movq (%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x41f0
movl $0x1, %edi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/export.c
// Function: tagreflect
void
tagreflect(Type *t)
{
	size_t i;

	if (hasparams(t) || t->isreflect)
		return;

	t->isreflect = 1;
	for (i = 0; i < t->nsub; i++)
		tagreflect(t->sub[i]);
	switch (t->type) {
	case Tystruct:
		for (i = 0; i < t->nmemb; i++)
			tagreflect(decltype(t->sdecls[i]));
		break;
	case Tyunion:
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype)
				tagreflect(t->udecls[i]->etype);
		break;
	case Tyname:
		for (i = 0; i < t->narg; i++)
			tagreflect(t->arg[i]);
	default:
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x231e7
testl %eax, %eax
jne 0x13a69
cmpb $0x0, 0x95(%rbx)
je 0x13a71
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x95(%rbx)
cmpq $0x0, 0x70(%rbx)
je 0x13a98
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x13a50
incq %r14
cmpq 0x70(%rbx), %r14
jb 0x13a82
movl (%rbx), %eax
cmpl $0x17, %eax
je 0x13b01
cmpl $0x18, %eax
je 0x13acb
cmpl $0x1c, %eax
jne 0x13a69
cmpq $0x0, 0x48(%rbx)
je 0x13a69
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x13a50
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x13ab3
jmp 0x13a69
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x13a69
xorl %r14d, %r14d
movq 0x88(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq 0x28(%rcx), %rdi
testq %rdi, %rdi
je 0x13af4
callq 0x13a50
movq 0x78(%rbx), %rax
incq %r14
cmpq %rax, %r14
jb 0x13ad7
jmp 0x13a69
cmpq $0x0, 0x78(%rbx)
je 0x13a69
xorl %r14d, %r14d
movq 0x88(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1e31c
movq %rax, %rdi
callq 0x13a50
incq %r14
cmpq 0x78(%rbx), %r14
jb 0x13b0f
jmp 0x13a69
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/export.c
// Function: tagtrait
static void
tagtrait(Stab *st, Trait *tr, int ingeneric, int hidelocal)
{
	size_t i;

	if (!tr)
		return;
	if (tr->vis != Visintern)
		return;

	tr->vis = Vishidden;
	if (tr->param)
		tagtype(st, tr->param, ingeneric, hidelocal);
	for (i = 0; i < tr->naux; i++)
		tagtype(st, tr->aux[i], ingeneric, hidelocal);
	for (i = 0; i < tr->nproto; i++)
		tagnode(st, tr->proto[i], ingeneric, hidelocal);
}

// Assembly:
testq %rdi, %rdi
je 0x1440f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0xc(%rdi)
jne 0x14405
movl %edx, %ebx
movl %esi, %ebp
movl $0x2, 0xc(%r14)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x143bd
movl %ebp, %esi
movl %ebx, %edx
callq 0x1414a
cmpq $0x0, 0x28(%r14)
je 0x143e1
xorl %r15d, %r15d
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1414a
incq %r15
cmpq 0x28(%r14), %r15
jb 0x143c7
cmpq $0x0, 0x38(%r14)
je 0x14405
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x13e88
incq %r15
cmpq 0x38(%r14), %r15
jb 0x143eb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/fold.c
// Function: getintlit
int
getintlit(Node *n, vlong *v)
{
	Node *l;

	if (exprop(n) != Olit)
		return 0;
	l = n->expr.args[0];
	/* It's up to type checking to make sure this is ok */
	if (l->lit.littype == Lint)
		*v = l->lit.intval;
	else if (l->lit.littype == Lchr)
		*v = l->lit.chrval;
	else
		return 0;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d422
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x35, %ecx
jne 0x1444c
movq 0x50(%r14), %rcx
movq (%rcx), %rcx
movl 0x18(%rcx), %edx
testl %edx, %edx
je 0x14441
cmpl $0x2, %edx
jne 0x1444c
movq 0x30(%rcx), %rax
jmp 0x14444
movl 0x30(%rcx), %eax
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/fold.c
// Function: idxcmp
int
idxcmp(const void *pa, const void *pb)
{
	Node *a, *b;
	vlong av, bv;

	a = *(Node **)pa;
	b = *(Node **)pb;

	assert(getintlit(a->expr.idx, &av));
	assert(getintlit(b->expr.idx, &bv));

	/* don't trust overflow with int64 */
	if (av < bv)
		return -1;
	else if (av == bv)
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq (%rsi), %rbx
movq 0x48(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x14410
testl %eax, %eax
je 0x1449d
movq 0x48(%rbx), %rdi
movq %rsp, %rsi
callq 0x14410
testl %eax, %eax
je 0x144bc
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
cmpq (%rsp), %rax
setne %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1e9c0(%rip), %rdi     # 0x32e64
leaq 0x1e9d5(%rip), %rsi     # 0x32e80
leaq 0x1e9d5(%rip), %rcx     # 0x32e87
movl $0x77, %edx
callq 0x4180
leaq 0x1e9eb(%rip), %rdi     # 0x32eae
leaq 0x1e9b6(%rip), %rsi     # 0x32e80
leaq 0x1e9b6(%rip), %rcx     # 0x32e87
movl $0x78, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/fold.c
// Function: val
static Node *
val(Srcloc loc, vlong val, Type *t)
{
	Node *l, *n;

	l = mkint(loc, val);
	n = mkexpr(loc, Olit, l, NULL);
	l->lit.type = t;
	n->expr.type = t;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1dec1
movq %rax, %r15
movq %r14, %rdi
movl $0x35, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rbx, 0x20(%r15)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/fold.c
// Function: issmallconst
static int
issmallconst(Node *dcl)
{
	Type *t;

	if (!dcl->decl.isconst)
		return 0;
	if (!dcl->decl.init)
		return 0;
	t = tybase(exprtype(dcl->decl.init));
	if (t->type <= Tyflt64)
		return 1;
	return 0;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x72(%rdi)
je 0x14bad
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x14bad
pushq %rax
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x11, (%rcx)
setb %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/fold.c
// Function: foldcast
static Node *
foldcast(Node *n)
{
	Type *to, *from;
	Node *sub;

	sub = n->expr.args[0];
	to = exprtype(n);
	from = exprtype(sub);

	switch (tybase(to)->type) {
	case Tybool:
	case Tyint8: case Tyint16: case Tyint32: case Tyint64:
	case Tyuint8: case Tyuint16: case Tyuint32: case Tyuint64:
	case Tyint: case Tyuint: case Tychar: case Tybyte:
	case Typtr:
		switch (tybase(from)->type) {
		case Tybool:
		case Tyint8: case Tyint16: case Tyint32: case Tyint64:
		case Tyuint8: case Tyuint16: case Tyuint32: case Tyuint64:
		case Tyint: case Tyuint: case Tychar: case Tybyte:
		case Typtr:
			if (exprop(sub) == Olit || tybase(from)->type == tybase(to)->type) {
				sub->expr.type = to;
				return sub;
			} else {
				return n;
			}
		default:
			return n;
		}
	default:
		return n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq (%rax), %r14
callq 0x1e384
movq %rax, %r15
movq %r14, %rdi
callq 0x1e384
movq %rax, %r12
movq %r15, %rdi
callq 0x227ac
movl (%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0xd, %ecx
jae 0x14c2d
movq %r12, %rdi
callq 0x227ac
movl (%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0xd, %ecx
jae 0x14c34
movq %r14, %rdi
callq 0x1d422
cmpl $0x35, %eax
je 0x14c1a
movq %r12, %rdi
callq 0x227ac
movl (%rax), %ebp
movq %r15, %rdi
callq 0x227ac
cmpl (%rax), %ebp
jne 0x14c21
movq %r15, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x12, %eax
je 0x14be5
jmp 0x14c21
cmpl $0x12, %eax
je 0x14bf7
jmp 0x14c21
nop
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/gram.c
// Function: yy_symbol_print
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbx
cmpl $0x54, %esi
leaq 0x1e82d(%rip), %rax     # 0x353fc
leaq 0x1e82c(%rip), %rdx     # 0x35402
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x2ca79(%rip), %rcx     # 0x43660
movq (%rcx,%rax,8), %rcx
leaq 0x1e802(%rip), %rsi     # 0x353f4
xorl %eax, %eax
callq 0x4240
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: tryconstrain
static int
tryconstrain(Type *base, Trait *tr, int update)
{
	Traitmap *tm;
	Bitset *bs;
	Type *ty;
	size_t i;

	while(1) {
		ty = base;
		tm = traitmap->sub[ty->type];
		while (1) {
			if (ty->type == Typaram)
				if (ty->trneed && bshas(ty->trneed, tr->uid))
					return 1;
			if (ty->type == Tyvar) {
				if (!ty->trneed)
					ty->trneed = mkbs();
				if (update)
					bsput(ty->trneed, tr->uid);
				return 1;
			}
			if (bshas(tm->traits, tr->uid))
				return 1;
			if (tm->name && ty->type == Tyname) {
				bs = htget(tm->name, ty->name);
				if (bs && bshas(bs, tr->uid))
					return 1;
			}
			for (i = 0; i < tm->nfilter; i++) {
				if (tm->filtertr[i]->uid != tr->uid)
					continue;
				if (tymatchrank(tm->filter[i], ty) >= 0)
					return 1;
			}
			if (!ty->sub || ty->nsub != 1)
				break;
			ty = ty->sub[0];
			tm = tm->sub[ty->type];
			if (!tm)
				break;
		}
		if (base->type != Tyname)
			break;
		base = base->sub[0];
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x4a380(%rip), %rcx     # 0x617b0
movl (%r14), %eax
movq 0x8(%rcx,%rax,8), %r12
movq %r14, %r15
cmpl $0x1a, %eax
je 0x1744d
cmpl $0x19, %eax
je 0x17592
movl (%rbx), %ecx
jmp 0x17483
movq 0x80(%r15), %rdx
movl (%rbx), %ecx
testq %rdx, %rdx
je 0x17483
movslq %ecx, %rsi
movq (%rdx), %rdi
shlq $0x6, %rdi
cmpq %rsi, %rdi
jbe 0x17483
movq 0x8(%rdx), %rdx
movq %rsi, %rdi
shrq $0x6, %rdi
movq (%rdx,%rdi,8), %rdx
btq %rsi, %rdx
jb 0x1757a
movq (%r12), %rdx
movslq %ecx, %rcx
movq (%rdx), %rsi
shlq $0x6, %rsi
cmpq %rcx, %rsi
jbe 0x174af
movq 0x8(%rdx), %rdx
movq %rcx, %rsi
shrq $0x6, %rsi
movq (%rdx,%rsi,8), %rdx
btq %rcx, %rdx
jb 0x1757a
cmpl $0x1c, %eax
jne 0x174fa
movq 0x100(%r12), %rdi
testq %rdi, %rdi
je 0x174fa
movq 0x88(%r15), %rsi
callq 0x2d8fa
testq %rax, %rax
je 0x174fa
movslq (%rbx), %rcx
movq (%rax), %rdx
shlq $0x6, %rdx
cmpq %rcx, %rdx
jbe 0x174fa
movq 0x8(%rax), %rax
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rax
btq %rcx, %rax
jb 0x1757a
movq 0x110(%r12), %rax
testq %rax, %rax
je 0x17544
xorl %r13d, %r13d
movq 0x118(%r12), %rcx
movq (%rcx,%r13,8), %rcx
movl (%rcx), %ecx
cmpl (%rbx), %ecx
jne 0x1753c
movq 0x108(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x170b6
testl %eax, %eax
jns 0x1757a
movq 0x110(%r12), %rax
incq %r13
cmpq %rax, %r13
jb 0x1750a
movq 0x68(%r15), %rax
testq %rax, %rax
je 0x17568
cmpq $0x1, 0x70(%r15)
jne 0x17568
movq (%rax), %r15
movl (%r15), %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
jne 0x1743b
cmpl $0x1c, (%r14)
jne 0x175c1
movq 0x68(%r14), %rax
movq (%rax), %r14
jmp 0x17429
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x80(%r15), %rdi
testq %rdi, %rdi
jne 0x175ad
callq 0x2d13c
movq %rax, %rdi
movq %rax, 0x80(%r15)
movl $0x1, %r14d
testl %ebp, %ebp
je 0x17580
movslq (%rbx), %rsi
callq 0x2d369
jmp 0x17580
xorl %r14d, %r14d
jmp 0x17580
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: addbindings
void
addbindings(Node *n, Node **bind, size_t nbind)
{
	size_t i;

	/* order of binding shouldn't matter, so push them into the block
	 * in reverse order. */
	for (i = 0; i < nbind; i++) {
		putdcl(n->block.scope, bind[i]);
		linsert(&n->block.stmts, &n->block.nstmts, 0, bind[i]);
	}
}

// Assembly:
testq %rdx, %rdx
je 0x1761d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %r12
leaq 0x20(%rdi), %r13
xorl %ebp, %ebp
movq 0x18(%r15), %rdi
movq (%r14,%rbp,8), %rsi
callq 0x204de
movq (%r14,%rbp,8), %rcx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2cf6a
incq %rbp
cmpq %rbp, %rbx
jne 0x175e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: inferstab
static void
inferstab(Stab *s)
{
	void **k;
	size_t n, i;
	Node *dcl;
	Type *t;
	void *se;

	k = htkeys(s->dcl, &n);
	se = curenv();
	for (i = 0; i < n; i++) {
		dcl = htget(s->dcl, k[i]);
		pushenv(dcl->decl.env);
		tf(type(dcl));
		popenv(dcl->decl.env);
		assert(se == curenv());
	}
	free(k);

	k = htkeys(s->ty, &n);
	for (i = 0; i < n; i++) {
		t = gettype(s, k[i]);
		if (!t)
			fatal(k[i], "undefined type %s", namestr(k[i]));
		t = tysearch(t);
		setsuperenv(t->env, curenv());
		pushenv(t->env);
		tyresolve(t);
		popenv(t->env);
		updatetype(s, k[i], t);
	}
	free(k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2da36
movq %rax, %r14
callq 0x1fefd
cmpq $0x0, (%r12)
je 0x18702
movq %rax, %r15
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
movq (%r14,%r13,8), %rsi
callq 0x2d8fa
movq %rax, %r12
movq 0x38(%rax), %rdi
callq 0x1ff19
movq %r12, %rdi
callq 0x1b51f
movq %rax, %rdi
callq 0x19640
movq 0x38(%r12), %rdi
callq 0x1ff64
callq 0x1fefd
cmpq %rax, %r15
jne 0x187af
incq %r13
cmpq (%rsp), %r13
jb 0x186b8
movq %r14, %rdi
callq 0x4040
movq 0x28(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x2da36
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x18798
xorl %r12d, %r12d
leaq 0x49aa4(%rip), %r13     # 0x621d0
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x20396
testq %rax, %rax
je 0x187ce
movq (%r13), %rcx
movq %rax, %r15
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x18745
movq 0x60(%r15), %rbp
callq 0x1fefd
testq %rbp, %rbp
je 0x18766
movq %rax, (%rbp)
movq 0x60(%r15), %rdi
callq 0x1ff19
movq %r15, %rdi
callq 0x1ac8d
movq 0x60(%r15), %rdi
callq 0x1ff64
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x207ee
incq %r12
cmpq (%rsp), %r12
jb 0x1872c
movq %r14, %rdi
callq 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1db6f(%rip), %rdi     # 0x36325
leaq 0x1dafb(%rip), %rsi     # 0x362b8
leaq 0x1db70(%rip), %rcx     # 0x36334
movl $0x80a, %edx            # imm = 0x80A
callq 0x4180
movq (%r14,%r12,8), %rbx
movq %rbx, %rdi
callq 0x1e4eb
leaq 0x1db6a(%rip), %rsi     # 0x3634b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: tf
static Type *
tf(Type *orig)
{
	int isgeneric;
	Type *t, *tt;

	assert(orig != NULL);
	t = tylookup(orig);
	isgeneric = t->type == Tygeneric;
	ingeneric += isgeneric;
	pushenv(orig->env);
	tyresolve(t);
	if ((tt = boundtype(t)) != NULL) {
		t = tt;
		tyresolve(t);
	}
	popenv(orig->env);
	/* If this is an instantiation of a generic type, we want the params to
	 * match the instantiation */
	if (orig->type == Tyunres && t->type == Tygeneric) {
		if (t->ngparam != orig->narg) {
			lfatal(orig->loc, "%s incompatibly specialized with %s, declared on %s:%d",
					tystr(orig), tystr(t), file.files[t->loc.file], t->loc.line);
		}
		pushenv(orig->env);
		t = tysubst(t, orig);
		popenv(orig->env);
	}
	ingeneric -= isgeneric;
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x197c2
movq %rdi, %rbx
leaq 0x48b76(%rip), %r15     # 0x621d0
movq (%r15), %rcx
movq %rdi, %r14
movl 0x4(%r14), %edx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x196bf
cmpl $0x1b, (%r14)
jne 0x196bf
callq 0x1fdf7
movq 0x88(%r14), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x1968b
callq 0x1ffef
movq 0x88(%r14), %rsi
testq %rax, %rax
je 0x1978c
movq %rax, %rdi
callq 0x20396
testq %rax, %rax
je 0x1979f
movq (%r15), %rcx
movl 0x4(%r14), %edx
cmpq %r14, %rax
je 0x196bf
movq %rax, (%rcx,%rdx,8)
movq (%r15), %rcx
movq (%rcx,%rdx,8), %rax
testq %rax, %rax
je 0x196e7
movl 0x4(%rax), %esi
movq (%rcx,%rsi,8), %rsi
movq %rax, %r14
testq %rsi, %rsi
je 0x19660
movq %rsi, (%rcx,%rdx,8)
movq (%r15), %rcx
movq (%rcx,%rdx,8), %r14
jmp 0x19660
xorl %ebp, %ebp
cmpl $0x1d, (%r14)
sete %bpl
addl %ebp, 0x481f9(%rip)     # 0x618f0
movq 0x60(%rbx), %rdi
callq 0x1ff19
movq %r14, %rdi
callq 0x1ac8d
movq %r14, %rdi
callq 0x21019
testq %rax, %rax
je 0x19723
movq %rax, %r15
movq %rax, %rdi
callq 0x1ac8d
movq %r15, %r14
movq 0x60(%rbx), %rdi
callq 0x1ff64
cmpl $0x1b, (%rbx)
jne 0x19778
cmpl $0x1d, (%r14)
jne 0x19778
movq 0x38(%r14), %rax
cmpq 0x48(%rbx), %rax
jne 0x197e1
movq 0x60(%rbx), %rdi
callq 0x1ff19
callq 0x1e744
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b68d
movq %rax, %r14
movq %r15, %rdi
callq 0x1e785
movq 0x60(%rbx), %rdi
callq 0x1ff64
subl %ebp, 0x48172(%rip)     # 0x618f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsi), %rdx
leaq 0x1cb71(%rip), %rax     # 0x36308
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x197bb
movq 0x88(%r14), %rbx
movq %r14, %rdi
callq 0x2398e
leaq 0x1cb65(%rip), %rsi     # 0x3631a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x138e7
leaq 0x1cae2(%rip), %rdi     # 0x362ab
leaq 0x1cae8(%rip), %rsi     # 0x362b8
leaq 0x1cae9(%rip), %rcx     # 0x362c0
movl $0x289, %edx            # imm = 0x289
callq 0x4180
movq %rbx, %rdi
callq 0x2398e
movq %rax, %r15
movq %r14, %rdi
callq 0x2398e
leaq 0x47a7d(%rip), %rcx     # 0x61278
movq 0x8(%rcx), %rcx
movslq 0xc(%r14), %rdx
movq (%rcx,%rdx,8), %r8
movl 0x8(%r14), %r9d
movq 0x8(%rbx), %rdi
leaq 0x1cabb(%rip), %rsi     # 0x362d1
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x139d2
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: mktraitmap
static Traitmap *
mktraitmap(void)
{
	Traitmap *m;

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

// Assembly:
pushq %rbx
movl $0x128, %edi            # imm = 0x128
callq 0x2ce48
movq %rax, %rbx
callq 0x2d13c
movq %rax, (%rbx)
leaq 0x4c51(%rip), %rdi      # 0x1e491
leaq 0x4cdc(%rip), %rsi      # 0x1e523
callq 0x2d678
movq %rax, 0x100(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: nodetystr
static char *
nodetystr(Node *n)
{
	Type *t;

	t = NULL;
	if (n->type == Nexpr && exprtype(n) != NULL)
		t = tysearch(exprtype(n));
	else if (n->type == Ndecl && decltype(n) != NULL)
		t = tysearch(decltype(n));

	if (t && tybase(t)->type != Tyvar)
		return tystr(t);
	else
		return strdup("unknown");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x8, %eax
jne 0x19c84
movq %rbx, %rdi
callq 0x1e384
testq %rax, %rax
je 0x19c81
movq %rbx, %rdi
callq 0x1e384
testq %rax, %rax
je 0x19cc9
leaq 0x48563(%rip), %rcx     # 0x621d0
movq (%rcx), %rcx
movq %rax, %rbx
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x19c70
jmp 0x19cbc
movl 0x8(%rbx), %eax
cmpl $0xb, %eax
jne 0x19cc9
movq %rbx, %rdi
callq 0x1e31c
testq %rax, %rax
je 0x19cc9
movq %rbx, %rdi
callq 0x1e31c
testq %rax, %rax
je 0x19cc9
leaq 0x48526(%rip), %rcx     # 0x621d0
movq (%rcx), %rcx
movq %rax, %rbx
movl 0x4(%rax), %eax
movq (%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x19cad
movq %rbx, %rdi
callq 0x227ac
cmpl $0x19, (%rax)
jne 0x19cd6
leaq 0x1c2c3(%rip), %rdi     # 0x35f93
popq %rbx
jmp 0x4340
movq %rbx, %rdi
popq %rbx
jmp 0x2398e
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: ctxstrcall
static void
ctxstrcall(char *buf, size_t sz, Node *n)
{
	char *p, *end, *sep, *t;
	size_t nargs, i;
	Node **args;
	Type *et;

	args = n->expr.args;
	nargs = n->expr.nargs;
	p = buf;
	end = buf + sz;
	sep = "";

	if (exprop(args[0]) == Ovar)
		p += bprintf(p, end - p, "%s(", namestr(args[0]->expr.args[0]));
	else
		p += bprintf(p, end - p, "<e>(");
	for (i = 1; i < nargs; i++) {
		et = tyfix(NULL, exprtype(args[i]), 1);
		if (et != NULL)
			t = tystr(et);
		else
			t = strdup("?");

		if (exprop(args[i]) == Ovar)
			p += bprintf(p, end - p, "%s%s:%s", sep, namestr(args[i]->expr.args[0]), t);
		else
			p += bprintf(p, end - p, "%s<e%zd>:%s", sep, i, t);
		sep = ", ";
		free(t);
	}
	if (exprtype(args[0])->nsub)
		t = tystr(tyfix(NULL, exprtype(args[0])->sub[0], 1));
	else
		t = strdup("unknown");
	p += bprintf(p, end - p, "): %s", t);
	free(t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x40(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsi), %rbp
movq (%rbp), %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0x19d36
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x1e4eb
leaq 0x1c279(%rip), %rdx     # 0x35f9b
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2dfae
jmp 0x19d4c
leaq 0x1c262(%rip), %rdx     # 0x35f9f
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
xorl %eax, %eax
callq 0x2dfae
movq %rax, %rbx
leaq 0x200(%r15), %rax
movq %rax, 0x10(%rsp)
addq %r15, %rbx
cmpq $0x2, 0x8(%rsp)
jb 0x19e28
movl $0x1, %r15d
leaq 0x180d3(%rip), %r12     # 0x31e4a
movq (%rbp,%r15,8), %rdi
callq 0x1e384
xorl %edi, %edi
movq %rax, %rsi
movl $0x1, %edx
callq 0x19e9f
testq %rax, %rax
je 0x19d9f
movq %rax, %rdi
callq 0x2398e
jmp 0x19dab
leaq 0x1c16c(%rip), %rdi     # 0x35f12
callq 0x4340
movq %rax, %r13
movq (%rbp,%r15,8), %rdi
callq 0x1d422
movq 0x10(%rsp), %r14
subq %rbx, %r14
cmpl $0x33, %eax
jne 0x19deb
movq (%rbp,%r15,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x1e4eb
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1c1c1(%rip), %rdx     # 0x35fa4
movq %r12, %rcx
movq %rax, %r8
jmp 0x19dfe
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x1c1b4(%rip), %rdx     # 0x35fac
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x2dfae
addq %rax, %rbx
movq %r13, %rdi
callq 0x4040
incq %r15
leaq 0x1c19b(%rip), %r12     # 0x35fb8
cmpq %r15, 0x8(%rsp)
jne 0x19d77
movq (%rbp), %rdi
callq 0x1e384
cmpq $0x0, 0x70(%rax)
je 0x19e5e
movq (%rbp), %rdi
callq 0x1e384
movq 0x68(%rax), %rax
movq (%rax), %rsi
xorl %edi, %edi
movl $0x1, %edx
callq 0x19e9f
movq %rax, %rdi
callq 0x2398e
jmp 0x19e6a
leaq 0x1c12e(%rip), %rdi     # 0x35f93
callq 0x4340
movq %rax, %r15
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
leaq 0x1c13f(%rip), %rdx     # 0x35fbb
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2dfae
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: traitsfor
static void
traitsfor(Type *base, Bitset *dst)
{
	Traitmap *tm;
	Bitset *bs;
	Type *ty;
	size_t i;

	while(1) {
		ty = base;
		tm = traitmap->sub[ty->type];
		while (1) {
			if (ty->type == Tyvar)
				break;
			if (ty->type == Tyname && ty->ngparam == 0)
				bs = htget(tm->name, ty->name);
			else
				bs = tm->traits;
			if (bs)
				bsunion(dst, bs);
			for (i = 0; i < tm->nfilter; i++) {
				if (tymatchrank(tm->filter[i], ty) >= 0)
					bsput(dst, tm->filtertr[i]->uid);
			}
			if (!tm->sub[ty->type] || ty->nsub != 1)
				break;
			tm = tm->sub[ty->type];
			ty = ty->sub[0];
		}
		if (base->type != Tyname)
			break;
		base = base->sub[0];
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x474fb(%rip), %rcx     # 0x617b0
movl (%r14), %eax
movq 0x8(%rcx,%rax,8), %r12
movq %r14, %r15
cmpl $0x1c, %eax
je 0x1a2cf
cmpl $0x19, %eax
jne 0x1a2d6
jmp 0x1a370
cmpq $0x0, 0x38(%r15)
je 0x1a354
movq (%r12), %rsi
testq %rsi, %rsi
je 0x1a2e7
movq %rbx, %rdi
callq 0x2d3f9
cmpq $0x0, 0x110(%r12)
je 0x1a331
xorl %r13d, %r13d
movq 0x108(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x170b6
testl %eax, %eax
js 0x1a324
movq 0x118(%r12), %rax
movq (%rax,%r13,8), %rax
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x2d369
incq %r13
cmpq 0x110(%r12), %r13
jb 0x1a2f5
movl (%r15), %eax
movq 0x8(%r12,%rax,8), %r12
testq %r12, %r12
je 0x1a370
cmpq $0x1, 0x70(%r15)
jne 0x1a370
movq 0x68(%r15), %rax
movq (%rax), %r15
movl (%r15), %eax
jmp 0x1a2c0
movq 0x100(%r12), %rdi
movq 0x88(%r15), %rsi
callq 0x2d8fa
movq %rax, %rsi
jmp 0x1a2da
cmpl $0x1c, (%r14)
jne 0x1a382
movq 0x68(%r14), %rax
movq (%rax), %r14
jmp 0x1a2ae
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: marksrc
static void
marksrc(Type *t, Srcloc l)
{
	t = tf(t);
	if (t->tid >= nunifysrc) {
		unifysrc = zrealloc(unifysrc, nunifysrc*sizeof(Srcloc), (t->tid + 1)*sizeof(Srcloc));
		nunifysrc = t->tid + 1;
	}
	if (unifysrc[t->tid].line <= 0)
		unifysrc[t->tid] = l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x19640
movq %rax, %r14
movl 0x4(%rax), %edx
movq 0x468e2(%rip), %rsi     # 0x618e0
movq 0x468e3(%rip), %rax     # 0x618e8
cmpq %rdx, %rsi
ja 0x1b031
shlq $0x3, %rsi
incl %edx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x2cea2
movq %rax, 0x468c5(%rip)     # 0x618e8
movl 0x4(%r14), %edx
leal 0x1(%rdx), %ecx
movq %rcx, 0x468af(%rip)     # 0x618e0
cmpl $0x0, (%rax,%rdx,8)
jg 0x1b03b
movq %rbx, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: basetype
static Type *
basetype(Type *a)
{
	Type *t;

	t = a->seqaux;
	while (!t && a->type == Tyname) {
		a = a->sub[0];
		t = a->seqaux;
	}
	if (!t && (a->type == Tyslice || a->type == Tyarray || a->type == Typtr))
		t = a->sub[0];
	if (t)
		t = tf(t);
	return t;
}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
jne 0x1b077
movl (%rdi), %eax
cmpl $0x1c, %eax
jne 0x1b05c
movq 0x68(%rdi), %rax
movq (%rax), %rdi
jmp 0x1b043
cmpl $0x15, %eax
ja 0x1b07f
movl $0x340000, %ecx         # imm = 0x340000
btl %eax, %ecx
jae 0x1b07f
movq 0x68(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1b07f
movq %rax, %rdi
jmp 0x19640
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: typeerror
static void
typeerror(Type *a, Type *b, Node *ctx, char *msg)
{
	char *t1, *t2, *s1, *s2, *c;

	t1 = tystr(tyfix(NULL, a, 1));
	t2 = tystr(tyfix(NULL, b, 1));
	s1 = srcstr(a);
	s2 = srcstr(b);
	c = ctxstr(ctx);
	if (msg)
		fatal(ctx, "type \"%s\" incompatible with \"%s\" near %s: %s%s%s", t1, t2, c, msg, s1, s2);
	else
		fatal(ctx, "type \"%s\" incompatible with \"%s\" near %s%s%s", t1, t2, c, s1, s2);
	free(t1);
	free(t2);
	free(s1);
	free(s2);
	free(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r12
xorl %edi, %edi
movq %r12, %rsi
movl $0x1, %edx
callq 0x19e9f
movq %rax, %rdi
callq 0x2398e
movq %rax, %r15
xorl %edi, %edi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x19e9f
movq %rax, %rdi
callq 0x2398e
movq %rax, %r13
movq %r12, %rdi
callq 0x1b49b
movq %rax, %r12
movq %rbp, %rdi
callq 0x1b49b
movq %rax, %rbp
movq %r14, %rdi
callq 0x19858
testq %rbx, %rbx
jne 0x1b112
subq $0x8, %rsp
leaq 0x1b047(%rip), %rsi     # 0x36142
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %r12, %r9
xorl %eax, %eax
pushq %rbp
callq 0x138e7
leaq 0x1aff8(%rip), %rsi     # 0x36111
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
pushq %rbp
pushq %r12
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: occurs_rec
static int
occurs_rec(Type *sub, Bitset *bs)
{
	size_t i;

	sub = tf(sub);
	if (bshas(bs, sub->tid))
		return 1;
	bsput(bs, sub->tid);
	switch (sub->type) {
	case Typtr:
	case Tyslice:
		break;
	case Tystruct:
		for (i = 0; i < sub->nmemb; i++)
			if (occurs_rec(decltype(sub->sdecls[i]), bs))
				return 1;
		break;
	case Tyunion:
		for (i = 0; i < sub->nmemb; i++) {
			if (!sub->udecls[i]->etype)
				continue;
			if (occurs_rec(sub->udecls[i]->etype, bs))
				return 1;
		}
		break;
	default:
		for (i = 0; i < sub->nsub; i++)
			if (occurs_rec(sub->sub[i], bs))
				return 1;
		break;
	}
	bsdel(bs, sub->tid);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x19640
movq %rax, %r14
movl 0x4(%rax), %esi
movq (%rbx), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x1b3b5
movq 0x8(%rbx), %rax
movl %esi, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rcx
movl $0x1, %eax
btq %rsi, %rcx
jb 0x1b3ea
movq %rbx, %rdi
callq 0x2d369
movl (%r14), %eax
addl $-0x12, %eax
cmpl $0x6, %eax
ja 0x1b461
leaq 0x1a709(%rip), %rcx     # 0x35adc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x2d3d4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x1b3dc
xorl %r15d, %r15d
movq 0x88(%r14), %rcx
movq (%rcx,%r15,8), %rcx
movq 0x28(%rcx), %rdi
testq %rdi, %rdi
je 0x1b420
movq %rbx, %rsi
callq 0x1b37e
testl %eax, %eax
jne 0x1b491
movq 0x78(%r14), %rax
incq %r15
cmpq %rax, %r15
jb 0x1b3fc
jmp 0x1b3dc
cmpq $0x0, 0x78(%r14)
je 0x1b3dc
xorl %r15d, %r15d
movq 0x88(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e31c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b37e
testl %eax, %eax
jne 0x1b491
incq %r15
cmpq 0x78(%r14), %r15
jb 0x1b434
jmp 0x1b3dc
cmpq $0x0, 0x70(%r14)
je 0x1b3dc
xorl %r15d, %r15d
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1b37e
testl %eax, %eax
jne 0x1b491
incq %r15
cmpq 0x70(%r14), %r15
jb 0x1b46f
jmp 0x1b3dc
movl $0x1, %eax
jmp 0x1b3ea
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: srcstr
static char *
srcstr(Type *ty)
{
	char src[128];
	Srcloc l;
	char *s;

	src[0] = 0;
	if (nunifysrc > ty->tid && unifysrc[ty->tid].line > 0) {
		l = unifysrc[ty->tid];
		s = tystr(ty);
		snprintf(src, sizeof src, "\n\t%s from %s:%d", s, fname(l), lnum(l));
		free(s);
	}
	return strdup(src);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movb $0x0, (%rsp)
movl 0x4(%rdi), %eax
cmpq %rax, 0x4642b(%rip)     # 0x618e0
jbe 0x1b50a
movq 0x4642a(%rip), %rcx     # 0x618e8
cmpl $0x0, (%rcx,%rax,8)
jle 0x1b50a
movq (%rcx,%rax,8), %rbx
callq 0x2398e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d31c
movq %rax, %r15
movq %rbx, %rdi
callq 0x1d330
leaq 0x1ac85(%rip), %rdx     # 0x3616f
movq %rsp, %rdi
movl $0x80, %esi
movq %r14, %rcx
movq %r15, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x4150
movq %r14, %rdi
callq 0x4040
movq %rsp, %rdi
callq 0x4340
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: type
static Type *
type(Node *n)
{
	Type *t;

	switch (n->type) {
	case Nlit:	t = littype(n);	break;
	case Nexpr:	t = n->expr.type;	break;
	case Ndecl:	t = decltype(n);	break;
	case Nfunc:	t = n->func.type;	break;
	default:
		t = NULL;
		die("untypeable node %s", nodestr[n->type]);
		break;
	};
	return tf(t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
leal -0x8(%rax), %ecx
cmpl $0x4, %ecx
ja 0x1b63f
movq %rdi, %rbx
leaq 0x1a5bc(%rip), %rdx     # 0x35af8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x20(%rbx), %r14
jmp 0x1b62b
movq %rbx, %rdi
callq 0x1e31c
movq %rax, %r14
jmp 0x1b62b
movq 0x28(%rbx), %r14
jmp 0x1b62b
movq 0x20(%rbx), %r14
testq %r14, %r14
jne 0x1b62b
movl 0x18(%rbx), %eax
cmpq $0x7, %rax
ja 0x1b63a
leaq 0x1a584(%rip), %rcx     # 0x35b0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
movl $0x3, %esi
jmp 0x1b5fb
movq (%rbx), %rdi
movl $0x9, %esi
callq 0x2289d
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x22cd6
jmp 0x1b624
movq (%rbx), %rdi
callq 0x22b29
movq %rax, %r14
movq 0x46229(%rip), %rdi     # 0x617f0
jmp 0x1b5db
movq (%rbx), %rdi
callq 0x22b29
movq %rax, %r14
movq 0x46265(%rip), %rdi     # 0x61840
callq 0x2d180
movq %rax, 0x80(%r14)
jmp 0x1b627
movq (%rbx), %rdi
movl $0x1, %esi
jmp 0x1b5fb
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x2289d
jmp 0x1b624
movq 0x30(%rbx), %rax
movq 0x28(%rax), %r14
jmp 0x1b627
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x2289d
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x22d0e
movq %rax, %r14
movq %r14, 0x20(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19640
xorl %r14d, %r14d
jmp 0x1b627
leaq 0x4565a(%rip), %rcx     # 0x60ca0
movq (%rcx,%rax,8), %rsi
leaq 0x1ab91(%rip), %rdi     # 0x361e2
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: tysubst
static Type *
tysubst(Type *t, Type *orig)
{
	Tysubst *subst;

	subst = mksubst();
	t = tysubstmap(subst, t, orig);
	substfree(subst);
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e744
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b68d
movq %rax, %rbx
movq %r15, %rdi
callq 0x1e785
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: tysubstmap
static Type *
tysubstmap(Tysubst *subst, Type *t, Type *orig)
{
	size_t i;

	for (i = 0; i < t->ngparam; i++)
		substput(subst, t->gparam[i], tf(orig->arg[i]));
	t = tyfreshen(subst, t);
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x0, 0x38(%rsi)
je 0x1b6d5
movq %rdx, %r14
xorl %r13d, %r13d
movq 0x30(%rbx), %rax
movq (%rax,%r13,8), %r12
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x19640
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e6e8
incq %r13
cmpq 0x38(%rbx), %r13
jb 0x1b6a9
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1b6e6
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/infer.c
// Function: tyfreshen
static Type *
tyfreshen(Tysubst *subst, Type *orig)
{
	Type *ty, *base;

	if (!needfreshen(orig))
		return orig;
	pushenv(orig->env);
	if (!subst) {
		subst = mksubst();
		ty = tyspecialize(orig, subst, delayed);
		substfree(subst);
	} else {
		ty = tyspecialize(orig, subst, delayed);
	}
	ty->spec = orig->spec;
	ty->nspec = orig->nspec;
	base = basetype(ty);
	if (base)
		ty->seqaux = base;
	popenv(orig->env);
	return ty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d13c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b79b
movl %eax, %ebp
movq %r15, %rdi
callq 0x2d164
testl %ebp, %ebp
je 0x1b739
movq 0x60(%rbx), %rdi
callq 0x1ff19
testq %r14, %r14
je 0x1b73e
movq 0x46077(%rip), %rdx     # 0x617a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e7c0
movq %rax, %r14
jmp 0x1b763
movq %rbx, %r14
jmp 0x1b78d
callq 0x1e744
movq %rax, %r15
movq 0x46053(%rip), %rdx     # 0x617a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1e7c0
movq %rax, %r14
movq %r15, %rdi
callq 0x1e785
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1b043
testq %rax, %rax
je 0x1b784
movq %rax, 0x28(%r14)
movq 0x60(%rbx), %rdi
callq 0x1ff64
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq