LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktystruct
Type *
mktystruct(Srcloc loc, Node **decls, size_t ndecls)
{
	Type *t;
	Htab *ht;
	int i;
	char *s;

	t = mktype(loc, Tystruct);
	t->nsub = 0;
	t->nmemb = ndecls;

	ht = mkht(strhash, streq);
	for (i = 0; i < ndecls; i++) {
		s = declname(decls[i]);
		if (hthas(ht, s))
			fatal(decls[i], "duplicate struct member %s\n", declname(decls[i]));
		htput(ht, s, s);
	}
	htfree(ht);

	t->sdecls = memdup(decls, ndecls * sizeof(Node *));
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x17, %esi
callq 0x36c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x78(%rax)
leaq 0x1216b(%rip), %rdi     # 0x497e0
leaq 0x12334(%rip), %rsi     # 0x499b0
callq 0x48fe0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x37712
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x376f3
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x1c996(%rip), %rsi     # 0x54082
movb $0x0, %al
callq 0x1dfe0
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x49100
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3768c
movq -0x28(%rbp), %rdi
callq 0x490a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyunion
Type *
mktyunion(Srcloc loc, Ucon **decls, size_t ndecls)
{
	Type *t;

	t = mktype(loc, Tyunion);
	t->nmemb = ndecls;
	t->udecls = decls;
	return t;
}

// 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 $0x18, %esi
callq 0x36c10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%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/type.c
// Function: finducon
Ucon *
finducon(Type *ty, Node *name)
{
	size_t i;

	ty = tybase(ty);
	for (i = 0; i < ty->nmemb; i++)
		if (!strcmp(namestr(ty->udecls[i]->name), namestr(name)))
			return ty->udecls[i];
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x37836
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30600
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x37826
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3783e
jmp 0x37828
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x377c5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: istyunsigned
int
istyunsigned(Type *t)
{
	switch (tybase(t)->type) {
	case Tybyte:
	case Tyuint8:
	case Tyuint16:
	case Tyuint:
	case Tychar:
	case Tyuint32:
	case Tyuint64:
	case Tybool: return 1;
	default: return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addl $-0x2, %eax
subl $0x2, %eax
jb 0x37881
jmp 0x37874
movl -0x14(%rbp), %eax
addl $-0x9, %eax
subl $0x5, %eax
ja 0x3788a
jmp 0x37881
movl $0x1, -0x4(%rbp)
jmp 0x37891
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: hasparams
int
hasparams(Type *t)
{
	Bitset *visited;

	if (t->hasparams)
		return 1;
	visited = mkbs();
	t->hasparams = hasparamsrec(t, visited);
	bsfree(visited);
	return t->hasparams;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x90(%rax)
je 0x37d02
movl $0x1, -0x4(%rbp)
jmp 0x37d3b
callq 0x48650
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x379e0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x90(%rax)
movq -0x18(%rbp), %rdi
callq 0x48690
movq -0x10(%rbp), %rax
movsbl 0x90(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: traitfmt
int
traitfmt(char *buf, size_t len, Type *t)
{
	size_t i;
	char *p;
	char *end;
	char *sep;

	if (!t->trneed || !bscount(t->trneed))
		return 0;

	p = buf;
	end = p + len;

	p += bprintf(p, end - p, " :: ");
	sep = "";
	for (i = 0; bsiter(t->trneed, &i); i++) {
		p += bprintf(p, end - p, "%s%s", sep, namestr(traittab[i]->name));
		sep = ",";
	}
	return p - buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x37d88
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x487d0
cmpq $0x0, %rax
jne 0x37d94
movl $0x0, -0x4(%rbp)
jmp 0x37e7f
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq 0x1c2f5(%rip), %rdx     # 0x540b3
movb $0x0, %al
callq 0x4a230
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1da51(%rip), %rax     # 0x55825
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x37e71
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x45ef1(%rip), %rax     # 0x7dd10
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdi
callq 0x30600
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq %rax, %r8
leaq 0x15c9a(%rip), %rdx     # 0x4dae0
movb $0x0, %al
callq 0x4a230
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1d560(%rip), %rax     # 0x553bc
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x37de0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tyfmt
char *
tyfmt(char *buf, size_t len, Type *t)
{
	Bitset *bs;

	bs = mkbs();
	tybfmt(buf, len, bs, t);
	bsfree(bs);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x48650
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x37ee0
movq -0x20(%rbp), %rdi
callq 0x48690
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tyhash
ulong
tyhash(void *ty)
{
	size_t i;
	Type *t;
	ulong hash;

	t = (Type *)ty;
	switch (t->type) {
	case Tyvar:	hash = inthash(t->tid);	break;
	case Tyunion:	hash = inthash(t->type);	break;
	case Tystruct:	hash = inthash(t->type);	break;
	case Tyname:	hash = namehash(t->name);	break;
	case Typaram:	hash = strhash(t->pname);	break;
	default: hash = inthash(t->type); break;
	}

	for (i = 0; i < t->narg; i++)
		hash ^= tyhash(t->arg[i]);
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x17, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x38af2
movq -0x28(%rbp), %rax
leaq 0x1b529(%rip), %rcx     # 0x53fac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
callq 0x49b20
movq %rax, -0x20(%rbp)
jmp 0x38b03
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
callq 0x49b20
movq %rax, -0x20(%rbp)
jmp 0x38b03
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
callq 0x49b20
movq %rax, -0x20(%rbp)
jmp 0x38b03
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x305b0
movq %rax, -0x20(%rbp)
jmp 0x38b03
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x497e0
movq %rax, -0x20(%rbp)
jmp 0x38b03
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
callq 0x49b20
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x38b44
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x38a50
xorq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x38b0b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: equate
static void
equate(int32_t ta, int32_t tb)
{
	Typair *pa, *pb;

	/*
	 * unfortunately, we can't negatively cache
	 * here because tyvars may unify down and
	 * eventually make the negative result inaccurate.
	 */
	pa = zalloc(sizeof(Typair));
	*pa = (Typair){ta, tb};
	pb = zalloc(sizeof(Typair));
	*pb = (Typair){ta, tb};

	htput(eqcache, pa, pa);
	htput(eqcache, pb, pb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x8, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl -0x8(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movl -0x8(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq 0x44a69(%rip), %rdi     # 0x7dd18
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x49100
movq 0x44a55(%rip), %rdi     # 0x7dd18
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tystricteq
int
tystricteq(void *a, void *b)
{
	Bitset *avisited, *bvisited;
	int eq;

	if (a == b)
		return 1;
	avisited = mkbs();
	bvisited = mkbs();
	eq = tyeq_rec(a, b, avisited, bvisited, 0);
	bsfree(avisited);
	bsfree(bvisited);
	return eq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x39303
movl $0x1, -0x4(%rbp)
jmp 0x39348
callq 0x48650
movq %rax, -0x20(%rbp)
callq 0x48650
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x38b50
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x48690
movq -0x28(%rbp), %rdi
callq 0x48690
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tyeq
int
tyeq(void *a, void *b)
{
	Bitset *avisited, *bvisited;
	int eq;

	if (a == b)
		return 1;
	avisited = mkbs();
	bvisited = mkbs();
	eq = tyeq_rec(a, b, avisited, bvisited, 1);
	bsfree(avisited);
	bsfree(bvisited);
	return eq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x39383
movl $0x1, -0x4(%rbp)
jmp 0x393cb
callq 0x48650
movq %rax, -0x20(%rbp)
callq 0x48650
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %r8d
callq 0x38b50
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x48690
movq -0x28(%rbp), %rdi
callq 0x48690
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: disposableinit
void
disposableinit(Stab *st, Trait *tr)
{
	Node *func, *arg, **args;
	Type *ty;
	size_t nargs;

	tr->param = mktyparam(Zloc, "a");
	tr->naux = 0;

	/* __dispose__ : (val : @a -> void) */
	args = NULL;
	nargs = 0;
	arg = mkdecl(Zloc, mkname(Zloc, "val"), mktyparam(Zloc, "a"));
	lappend(&args, &nargs, arg);
	ty = mktyfunc(Zloc, args, nargs, mktype(Zloc, Tyvoid));

	func = mkdecl(Zloc, mkname(Zloc, "__dispose__"), ty);
	func->decl.trait = tr;
	func->decl.impls = mkht(tyhash, tyeq);
	func->decl.isgeneric = 1;
	func->decl.isconst = 1;
	func->decl.isglobl = 1;
	func->decl.isextern = 1;

	lappend(&tr->proto, &tr->nproto, func);
	putdcl(st, func);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x3c(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x172b6(%rip), %rsi     # 0x514c2
callq 0x370f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x44(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4c(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x19eb9(%rip), %rsi     # 0x54118
callq 0x2f540
movq %rax, -0x90(%rbp)
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x54(%rbp)
movq -0x58(%rbp), %rdi
leaq 0x1723e(%rip), %rsi     # 0x514c2
callq 0x370f0
movq -0x90(%rbp), %rsi
movq %rax, %rdx
movq -0x48(%rbp), %rdi
callq 0x2ff20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x48290
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x5c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0xffffffff, -0x68(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x64(%rbp)
movq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x36c10
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rax, %rcx
movq -0x60(%rbp), %rdi
callq 0x37520
movq %rax, -0x30(%rbp)
movl $0xffffffff, -0x70(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x6c(%rbp)
movl $0xffffffff, -0x78(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x74(%rbp)
movq -0x78(%rbp), %rdi
leaq 0x19df8(%rip), %rsi     # 0x54128
callq 0x2f540
movq %rax, %rsi
movq -0x30(%rbp), %rdx
movq -0x70(%rbp), %rdi
callq 0x2ff20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
leaq -0x190c(%rip), %rdi     # 0x38a50
leaq -0x1003(%rip), %rsi     # 0x39360
callq 0x48fe0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x73(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x72(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x71(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x74(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
movq -0x18(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33970
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: typaireq
static int
typaireq(void *a, void *b)
{
	Typair *pa, *pb;
	pa = a;
	pb = b;
	return pa->atid == pb->atid && pa->btid == pb->btid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x21(%rbp)
jne 0x3b903
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: namefmt
static int
namefmt(char *buf, size_t len, Node *n)
{
	char *p;
	char *end;

	p = buf;
	end = p + len;
	if (n->name.ns)
		p += bprintf(p, end - p, "%s.", n->name.ns);
	p += bprintf(p, end - p, "%s", n->name.name);
	return len - (end - p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3b970
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x13043(%rip), %rdx     # 0x4e9a4
movb $0x0, %al
callq 0x4a230
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x1710d(%rip), %rdx     # 0x52a9b
movb $0x0, %al
callq 0x4a230
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq %rdx, %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: fmtlist
static int
fmtlist(char *buf, size_t len, Bitset *visited, Type **arg, size_t narg)
{
	char *end, *p, *sep;
	size_t i;

	sep = "";
	p = buf;
	end = p + len;
	p += bprintf(p, end - p, "(");
	for (i = 0; i < narg; i++) {
		p += bprintf(p, end - p, "%s", sep);
		p += tybfmt(p, end - p, visited, arg[i]);
		sep = ", ";
	}
	p += bprintf(p, end - p, ")");
	return p - buf;
}

// 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)
leaq 0x19e42(%rip), %rax     # 0x55825
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
leaq 0x15899(%rip), %rdx     # 0x512aa
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3baa8
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
movq -0x40(%rbp), %rcx
leaq 0x1704f(%rip), %rdx     # 0x52a9b
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x37ee0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq 0x1649a(%rip), %rax     # 0x51f30
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x3ba28
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
leaq 0x17929(%rip), %rdx     # 0x533e7
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: fmtstruct
static int
fmtstruct(char *buf, size_t len, Bitset *visited, Type *t)
{
	size_t i;
	char *end, *p;
	char *name;
	char subbuf[512];

	p = buf;
	end = p + len;
	p += bprintf(p, end - p, "struct\n");
	for (i = 0; i < t->nmemb; i++) {
		name = declname(t->sdecls[i]);
		tybfmt(subbuf, sizeof subbuf, visited, decltype(t->sdecls[i]));
		p += bprintf(p, end - p, "\t%s:%s\n ", name, subbuf);
	}
	p += bprintf(p, end - p, ";;");
	return p - buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
leaq 0x18695(%rip), %rdx     # 0x541ba
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x3bbf7
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq %rax, -0x40(%rbp)
leaq -0x240(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq -0x250(%rbp), %rdi
movq -0x248(%rbp), %rdx
movq %rax, %rcx
movl $0x200, %esi            # imm = 0x200
callq 0x37ee0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
movq -0x40(%rbp), %rcx
leaq -0x240(%rbp), %r8
leaq 0x185eb(%rip), %rdx     # 0x541c2
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3bb3c
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
leaq 0x185be(%rip), %rdx     # 0x541cb
movb $0x0, %al
callq 0x4a230
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: addextlibs
void
addextlibs(char **libs, size_t nlibs)
{
	size_t i, j;

	for (i = 0; i < nlibs; i++) {
		for (j = 0; j < file.nextlibs; j++)
			if (!strcmp(file.extlibs[j], libs[i]))
				continue;
		lappend(&file.extlibs, &file.nextlibs, libs[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3bf3e
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x40ecf(%rip), %rcx     # 0x7cd98
cmpq 0x38(%rcx), %rax
jae 0x3bf0a
leaq 0x40ec2(%rip), %rax     # 0x7cd98
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x3befa
jmp 0x3befc
jmp 0x3befc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3bebe
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x40e7b(%rip), %rsi     # 0x7cd98
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x38, %rsi
callq 0x48290
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3bea8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: traitunpickle
Trait *
traitunpickle(FILE *fd)
{
	Trait *tr;
	Node *proto;
	size_t i, n;
	intptr_t uid;

	/* create an empty trait */
	tr = mktrait(Zloc, NULL, NULL,
		NULL, 0,
		NULL, 0,
		0);
	uid = rdint(fd);
	if (rdint(fd) == Vishidden)
		tr->ishidden = 1;
	tr->name = unpickle(fd);
	tr->param = tyunpickle(fd);
	tr->naux = rdint(fd);
	tr->aux = zalloc(tr->naux * sizeof(Type*));
	tr->isimport = 1;
	for (i = 0; i < tr->naux; i++)
		rdtype(fd, &tr->aux[i]);
	n = rdint(fd);
	for (i = 0; i < n; i++) {
		proto = rdsym(fd, tr);
		proto->decl.impls = mkht(tyhash, tyeq);
		lappend(&tr->proto, &tr->nproto, proto);
	}
	htput(trmap, itop(uid), tr);
	return tr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x34(%rbp)
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x36f00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
cmpq $0x2, %rax
jne 0x3bfbe
movq -0x10(%rbp), %rax
movb $0x1, 0x49(%rax)
movq -0x8(%rbp), %rdi
callq 0x3c110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x3c950
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
shlq $0x3, %rdi
callq 0x48160
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x4a(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x3c05e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3ced0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3c026
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3c0d3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3cfb0
movq %rax, -0x18(%rbp)
leaq -0x3645(%rip), %rdi     # 0x38a50
leaq -0x2d3c(%rip), %rsi     # 0x39360
callq 0x48fe0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
movq -0x18(%rbp), %rdx
callq 0x48290
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3c073
movq 0x41c56(%rip), %rax     # 0x7dd30
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3d120
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x49100
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: rdtype
static void
rdtype(FILE *fd, Type **dest)
{
	uintptr_t tid;

	tid = rdint(fd);
	if (tid == 0) {
		return;
	} else if (tid & Builtinmask) {
		*dest = mktype(Zloc, tid & ~Builtinmask);
	} else {
		typefix = xrealloc(typefix, (ntypefix + 1) * sizeof(typefix[0]));
		typefix[ntypefix++] = (Typefix){dest, tid};
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3cef9
jmp 0x3cf9e
movq -0x18(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x3cf38
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
andq $-0x40000001, %rax      # imm = 0xBFFFFFFF
movl %eax, %esi
movq -0x20(%rbp), %rdi
callq 0x36c10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3cf9c
movq 0x40e21(%rip), %rdi     # 0x7dd60
movq 0x40e22(%rip), %rsi     # 0x7dd68
addq $0x1, %rsi
shlq $0x4, %rsi
callq 0x48240
movq %rax, 0x40e06(%rip)     # 0x7dd60
movq 0x40dff(%rip), %rax     # 0x7dd60
movq 0x40e00(%rip), %rcx     # 0x7dd68
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x40df2(%rip)     # 0x7dd68
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3cf9e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: rdsym
static Node *
rdsym(FILE *fd, Trait *ctx)
{
	int line;
	Node *name;
	Node *n;

	line = rdint(fd);
	name = unpickle(fd);
	n = mkdecl(Zloc, name, NULL);
	n->loc.line = line;
	n->loc.file = file.nfiles - 1;
	rdtype(fd, &n->decl.type);

	if (rdint(fd) == Vishidden)
		n->decl.ishidden = 1;
	n->decl.trait = ctx;
	n->decl.isconst = rdbool(fd);
	n->decl.isgeneric = rdbool(fd);
	n->decl.isextern = rdbool(fd);
	n->decl.ispkglocal = rdbool(fd);
	n->decl.isnoret = rdbool(fd);
	n->decl.isimport = 1;
	n->decl.isexportval = rdbool(fd);
	n->decl.isinit = rdbool(fd);
	n->decl.isfini = rdbool(fd);
	if (n->decl.isexportval)
		n->decl.init = unpickle(fd);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c110
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2ff20
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
leaq 0x3fd8c(%rip), %rax     # 0x7cd98
movq (%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
addq $0x10, %rsi
callq 0x3ced0
movq -0x8(%rbp), %rdi
callq 0x49ff0
cmpq $0x2, %rax
jne 0x3d048
movq -0x28(%rbp), %rax
movb $0x1, 0x76(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x72(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x73(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x74(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x75(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x78(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x77(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x79(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x7a(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x7b(%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x79(%rax)
je 0x3d10a
movq -0x8(%rbp), %rdi
callq 0x3c110
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%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/use.c
// Function: findstab
static Stab *
findstab(Stab *st, char *pkg)
{
	Stab *s;

	if (!pkg) {
		if (!st->name)
			return st;
		else
			return NULL;
	}

	s = getns(pkg);
	if (!s) {
		s = mkstab(0);
		s->name = strdup(pkg);
		putns(s);
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3dc16
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3dc0c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3dc5a
movq $0x0, -0x8(%rbp)
jmp 0x3dc5a
movq -0x18(%rbp), %rdi
callq 0x330b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3dc52
xorl %edi, %edi
callq 0x32b90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x34860
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: fixtraitmappings
static void
fixtraitmappings(Stab *st)
{
	size_t i;
	Trait *t, *tr;

	/*
	* merge duplicate definitions.
	* This allows us to compare named types by id, instead
	* of doing a deep walk through the type. This ability is
	* depended on when we do type inference.
	*/
	for (i = 0; i < ntraitfix; i++) {
		t = htget(trmap, itop(traitfix[i].id));
		if (!t)
			die("Unable to find trait for id %zd\n", traitfix[i].id);

		tr = htget(trdeduptab, t->name);
		if (!tr) {
			htput(trdeduptab, t->name, t);
			tr = t;
		}
		if (traitfix[i].dest)
			*traitfix[i].dest = tr;
		if (traitfix[i].type && traitfix[i].type->type == Typaram) {
			if (!traitfix[i].type->trneed)
				traitfix[i].type->trneed = mkbs();
			bsput(traitfix[i].type->trneed, tr->uid);
		}
	}

	free(traitfix);
	traitfix = NULL;
	ntraitfix = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x3fe89(%rip), %rax     # 0x7dd58
jae 0x3e043
movq 0x3fe54(%rip), %rax     # 0x7dd30
movq %rax, -0x28(%rbp)
movq 0x3fe69(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x3d120
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x49490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3df30
movq 0x3fe3a(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
leaq 0x16685(%rip), %rdi     # 0x545ae
movb $0x0, %al
callq 0x1df20
movq 0x3fe01(%rip), %rdi     # 0x7dd38
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3df6f
movq 0x3fde2(%rip), %rdi     # 0x7dd38
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x49100
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x3fdda(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x3df9d
movq -0x20(%rbp), %rcx
movq 0x3fdc1(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x3fdac(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x3e030
movq 0x3fd96(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpl $0x1a, (%rax)
jne 0x3e030
movq 0x3fd7e(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3e00a
callq 0x48650
movq %rax, %rcx
movq 0x3fd59(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movq %rcx, 0x80(%rax)
movq 0x3fd3f(%rip), %rax     # 0x7dd50
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x48a50
jmp 0x3e032
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3dec4
movq 0x3fd06(%rip), %rdi     # 0x7dd50
callq 0x6040
movq $0x0, 0x3fcf6(%rip) # 0x7dd50
movq $0x0, 0x3fcf3(%rip) # 0x7dd58
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: fiximplmappings
static void
fiximplmappings(Stab *st)
{
	Node *impl;
	Trait *tr;
	size_t i, j;

	for (i = 0; i < nimplfix; i++) {
		impl = implfix[i];
		tr = impl->impl.trait;

		/* FIXME: handle duplicate impls properly */
		if (getimpl(st, impl))
			continue;
		putimpl(st, impl);
		for (j = 0; j < impl->impl.ndecls; j++) {
			putdcl(file.globls, impl->impl.decls[j]);
			protomap(tr, impl->impl.type, impl->impl.decls[j]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3fce9(%rip), %rax     # 0x7dd78
jae 0x3e151
movq 0x3fcd4(%rip), %rax     # 0x7dd70
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34710
cmpq $0x0, %rax
je 0x3e0c9
jmp 0x3e140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34600
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x3e13e
leaq 0x3eca5(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33970
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3fb60
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3e0de
jmp 0x3e140
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3e084
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: hassuffix
int
hassuffix(char *str, char *suff)
{
	size_t nstr, nsuff;

	nstr = strlen(str);
	nsuff = strlen(suff);
	if (nstr < nsuff)
		return 0;
	return !strcmp(str + nstr - nsuff, suff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3e19d
movl $0x0, -0x4(%rbp)
jmp 0x3e1c7
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x6220
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: traitpickle
static void
traitpickle(FILE *fd, Trait *tr)
{
	size_t i;

	wrint(fd, tr->uid);
	wrint(fd, tr->vis);
	pickle(fd, tr->name);
	typickle(fd, tr->param);
	wrint(fd, tr->naux);
	for (i = 0; i < tr->naux; i++)
		wrtype(fd, tr->aux[i]);
	wrint(fd, tr->nproto);
	for (i = 0; i < tr->nproto; i++)
		wrsym(fd, tr->proto[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %esi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3f0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3eac0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x49fb0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x3f052
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3fd00
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3f01d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x49fb0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x3f0a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3f700
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3f06b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: wrsym
static void
wrsym(FILE *fd, Node *val)
{
	/* sym */
	wrint(fd, val->loc.line);
	pickle(fd, val->decl.name);
	wrtype(fd, val->decl.type);

	/* symflags */
	wrint(fd, val->decl.vis);
	wrbool(fd, val->decl.isconst);
	wrbool(fd, val->decl.isgeneric);
	wrbool(fd, val->decl.isextern);
	wrbool(fd, val->decl.ispkglocal);
	wrbool(fd, val->decl.isnoret);
	wrbool(fd, val->decl.isexportval);
	wrbyte(fd, val->decl.isinit);
	wrbyte(fd, val->decl.isfini);
	if (val->decl.isexportval)
		pickle(fd, val->decl.init);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3f0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x3fd00
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbq 0x70(%rax), %rsi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x72(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x73(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x74(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x75(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x78(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x79(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x7a(%rax), %esi
callq 0x49f30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x7b(%rax), %esi
callq 0x49f30
movq -0x10(%rbp), %rax
cmpb $0x0, 0x79(%rax)
je 0x3f7f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x3f0b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: rdtrait
static void
rdtrait(FILE *fd, Trait **dest, Type *ty)
{
	uintptr_t tid;

	tid = rdint(fd);
	if (tid & Builtinmask) {
		if (dest)
			*dest = traittab[tid & ~Builtinmask];
		if (ty) {
			if (!ty->trneed)
				ty->trneed = mkbs();
			bsput(ty->trneed, traittab[tid & ~Builtinmask]->uid);
		}
	} else {
		traitfix = xrealloc(traitfix, (ntraitfix + 1) * sizeof(traitfix[0]));
		traitfix[ntraitfix++] = (Traitfix){dest, ty, tid};
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x3f8ae
cmpq $0x0, -0x10(%rbp)
je 0x3f858
leaq 0x3e4d1(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq -0x20(%rbp), %rcx
andq $-0x40000001, %rcx      # imm = 0xBFFFFFFF
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x3f8ac
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3f880
callq 0x48650
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
leaq 0x3e47e(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq -0x20(%rbp), %rcx
andq $-0x40000001, %rcx      # imm = 0xBFFFFFFF
movq (%rax,%rcx,8), %rax
movslq (%rax), %rsi
callq 0x48a50
jmp 0x3f922
movq 0x3e49b(%rip), %rdi     # 0x7dd50
movq 0x3e49c(%rip), %rax     # 0x7dd58
addq $0x1, %rax
imulq $0x18, %rax, %rsi
callq 0x48240
movq %rax, 0x3e480(%rip)     # 0x7dd50
movq 0x3e479(%rip), %rax     # 0x7dd50
movq 0x3e47a(%rip), %rcx     # 0x7dd58
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x3e46c(%rip)     # 0x7dd58
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: rducon
static Ucon *
rducon(FILE *fd, Type *ut)
{
	Type *et;
	Node *name;
	Ucon *uc;
	size_t id;
	int line;
	int synth;

	et = NULL;
	line = rdint(fd);
	id = rdint(fd);
	synth = rdbool(fd);
	name = unpickle(fd);
	uc = mkucon(Zloc, name, ut, et);
	uc->loc.line = line;
	uc->loc.file = file.nfiles - 1;
	if (rdbool(fd))
		rdtype(fd, &uc->etype);
	uc->id = id;
	uc->synth = synth;
	return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4a320
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c110
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rdi
callq 0x300c0
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
leaq 0x3d3e7(%rip), %rax     # 0x7cd98
movq (%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x4a320
cmpl $0x0, %eax
je 0x3f9e0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
callq 0x3ced0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: rdstab
static Stab *
rdstab(FILE *fd, int isfunc)
{
	Stab *st;
	Type *ty;
	Node *nm;
	int n;
	int i;

	/* read dcls */
	st = mkstab(isfunc);
	st->name = rdstr(fd);
	n = rdint(fd);
	for (i = 0; i < n; i++)
		putdcl(st, rdsym(fd, NULL));

	/* read types */
	n = rdint(fd);
	for (i = 0; i < n; i++) {
		nm = unpickle(fd);
		rdtype(fd, &ty);
		puttype(st, nm, ty);
	}
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x32b90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4a090
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x49ff0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3fa76
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3cfb0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x33970
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3fa42
movq -0x8(%rbp), %rdi
callq 0x49ff0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3fac7
movq -0x8(%rbp), %rdi
callq 0x3c110
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3ced0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x34140
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3fa89
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: isspecialization
static int
isspecialization(Type *t1, Type *t2)
{
	if ((t1->type != Tygeneric || t2->type != Tyname) &&
			(t1->type != Tyname || t2->type != Tygeneric) &&
			(t1->type != Tyname || t2->type != Tyname))
		return 0;
	/* FIXME: this should be done better */
	return nameeq(t1->name, t2->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1d, (%rax)
jne 0x3fb02
movq -0x18(%rbp), %rax
cmpl $0x1c, (%rax)
je 0x3fb2f
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x3fb14
movq -0x18(%rbp), %rax
cmpl $0x1d, (%rax)
je 0x3fb2f
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x3fb26
movq -0x18(%rbp), %rax
cmpl $0x1c, (%rax)
je 0x3fb2f
movl $0x0, -0x4(%rbp)
jmp 0x3fb4d
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x30670
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)