LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: bestimpl
static Node *
bestimpl(Node *n, Type *to)
{
	Node **gimpl, **ambig, *match;
	size_t ngimpl, nambig, i;
	int score;
	int best;

	if (hthas(n->decl.impls, to))
		return htget(n->decl.impls, to);
	ambig = NULL;
	match = NULL;
	nambig = 0;
	best = -1;
	gimpl = n->decl.gimpl;
	ngimpl = n->decl.ngimpl;
	for (i = 0; i < ngimpl; i++) {
		score = tymatchrank(decltype(gimpl[i]), to);
		if (score > best) {
			lfree(&ambig, &nambig);
			best = score;
			match = gimpl[i];
		} else if (score == best) {
			lappend(&ambig, &nambig, gimpl[i]);
		}
	}
	if (best < 0)
		return NULL;
	else if (nambig > 0)
		fatal(n, "ambiguous implementation for %s", tystr(to));
	return match;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x31e90
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x8(%rbp)
jmp 0x31fa7
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x31f60
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x254b0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jle 0x31f2a
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x48580
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x31f4d
movl -0x4c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jne 0x31f4b
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x48290
jmp 0x31f4d
jmp 0x31f4f
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x31ecf
cmpl $0x0, -0x50(%rbp)
jge 0x31f70
movq $0x0, -0x8(%rbp)
jmp 0x31fa7
cmpq $0x0, -0x40(%rbp)
jbe 0x31f9d
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38a10
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x2133e(%rip), %rsi     # 0x532d4
movb $0x0, %al
callq 0x1dfe0
jmp 0x31f9f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: fillsubst
static void
fillsubst(Tysubst *tsmap, Type *to, Type *from)
{
	size_t i;

	if (from->type == Typaram) {
		if (debugopt['S'])
			printf("mapping %s => %s\n", tystr(from), tystr(to));
		substput(tsmap, from, to);
		substputspec(tsmap, from, to);
		return;
	}
	assert(to->nsub == from->nsub);
	for (i = 0; i < to->nsub; i++)
		fillsubst(tsmap, to->sub[i], from->sub[i]);
	if (to->type == Tyname && to->narg > 0) {
		for (i = 0; i < to->narg; i++)
			fillsubst(tsmap, to->arg[i], from->arg[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x3203c
leaq 0x4ad1c(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x53(%rax)
je 0x32015
movq -0x18(%rbp), %rdi
callq 0x38a10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x212e6(%rip), %rdi     # 0x532f4
movb $0x0, %al
callq 0x6120
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x308e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x32930
jmp 0x3211f
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x32050
jmp 0x3206f
leaq 0x212af(%rip), %rdi     # 0x53306
leaq 0x2118b(%rip), %rsi     # 0x531e9
movl $0xea, %edx
leaq 0x212b3(%rip), %rcx     # 0x5331d
callq 0x6160
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x320bc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x31fc0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x32077
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x3211f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jbe 0x3211f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x3211d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x31fc0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x320d8
jmp 0x3211f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: initdecl
static Node *
initdecl(Node *name, Type *tyvoidfn)
{
	Node *dcl;

	dcl = getdcl(file.globls, name);
	if (!dcl) {
		dcl = mkdecl(Zloc, name, tyvoidfn);
		dcl->decl.isconst = 1;
		dcl->decl.isglobl = 1;
		dcl->decl.isinit = 1;
		dcl->decl.isextern = 1;
		dcl->decl.ishidden = 1;
		putdcl(file.globls, dcl);
	}
	return dcl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4a5c1(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x334b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x32854
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rdi
callq 0x2ff20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x72(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x71(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x7a(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x74(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x76(%rax)
leaq 0x4a554(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x33970
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: callinit
static void
callinit(Node *block, Node *init, Type *tyvoid, Type *tyvoidfn)
{
	Node *call, *var;

	var = mkexpr(Zloc, Ovar, init->decl.name, NULL);
	call = mkexpr(Zloc, Ocall, var, NULL);

	var->expr.type = tyvoidfn;
	call->expr.type = tyvoid;
	var->expr.did = init->decl.did;
	var->expr.isconst = 1;
	lappend(&block->block.stmts, &block->block.nstmts, call);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x38(%rbp), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x30(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x3c(%rbp)
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rdx
callq 0x48290
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/specialize.c
// Function: substputspec
static void
substputspec(Tysubst *tsmap, Type *from, Type *to)
{
	size_t ai, aj, bi, bj;

	for (ai = 0; ai < from->nspec; ai++) {
		for (aj = 0; aj < from->spec[ai]->ntrait; aj++) {
			for (bi = 0; bi < to->nspec; bi++) {
				for (bj = 0; bj < to->spec[bi]->ntrait; bj++) {
					if (nameeq(from->spec[ai]->trait[aj], to->spec[bi]->trait[bj]))
						fillsubst(tsmap, to->spec[ai]->aux, from->spec[bi]->aux);
				}
			}
			if (nameeq(from->spec[ai]->trait[aj], traittab[Tciter]->name))
				if (to->type == Tyslice || to->type == Tyarray)
					fillsubst(tsmap, to->sub[0], from->spec[ai]->aux);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x32af4
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x8(%rcx), %rax
jae 0x32ae1
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x32a5b
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x8(%rcx), %rax
jae 0x32a48
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x30670
cmpl $0x0, %eax
je 0x32a35
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdx
callq 0x31fc0
jmp 0x32a37
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x329a6
jmp 0x32a4a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3298c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4b293(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x30670
cmpl $0x0, %eax
je 0x32ace
movq -0x18(%rbp), %rax
cmpl $0x14, (%rax)
je 0x32aa4
movq -0x18(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x32acc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdx
callq 0x31fc0
jmp 0x32ace
jmp 0x32ad0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x32966
jmp 0x32ae3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3294c
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: mkstab
Stab *
mkstab(int isfunc)
{
	Stab *st;

	st = zalloc(sizeof(Stab));
	st->dcl = mkht(nsnamehash, nsnameeq);
	st->ty = mkht(nsnamehash, nsnameeq);
	st->tr = mkht(nsnamehash, nsnameeq);
	st->uc = mkht(nsnamehash, nsnameeq);
	if (isfunc) {
		st->env = mkht(nsnamehash, nsnameeq);
		st->lbl = mkht(strhash, streq);
	}
	st->impl = mkht(implhash, impleq);
	st->isfunc = isfunc;
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x90, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
leaq -0xb0(%rip), %rdi       # 0x32b00
leaq -0x87(%rip), %rsi       # 0x32b30
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0xce(%rip), %rdi       # 0x32b00
leaq -0xa5(%rip), %rsi       # 0x32b30
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
leaq -0xec(%rip), %rdi       # 0x32b00
leaq -0xc3(%rip), %rsi       # 0x32b30
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq -0x10a(%rip), %rdi      # 0x32b00
leaq -0xe1(%rip), %rsi       # 0x32b30
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpl $0x0, -0x4(%rbp)
je 0x32c63
leaq -0x12e(%rip), %rdi      # 0x32b00
leaq -0x105(%rip), %rsi      # 0x32b30
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x16b94(%rip), %rdi     # 0x497e0
leaq 0x16d5d(%rip), %rsi     # 0x499b0
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
leaq 0x36(%rip), %rdi        # 0x32ca0
leaq 0x7f(%rip), %rsi        # 0x32cf0
callq 0x48fe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: implhash
static ulong
implhash(void *p)
{
	Node *n;
	ulong h;

	n = p;
	h = nsnamehash(n->impl.traitname);
	h *= tyhash(n->impl.type);
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x32b00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x38a50
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: impleq
static int
impleq(void *pa, void *pb)
{
	Node *a, *b;

	a = pa;
	b = pb;
	if (nsnameeq(a->impl.traitname, b->impl.traitname))
		return tyeq(a->impl.type, b->impl.type);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x32b30
cmpl $0x0, %eax
je 0x32d44
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x39360
movl %eax, -0x4(%rbp)
jmp 0x32d4b
movl $0x0, -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/stab.c
// Function: mkenv
Tyenv*
mkenv()
{
	Tyenv *e;

	e = malloc(sizeof(Tyenv));
	e->super = NULL;
	e->tab = mkht(paramhash, parameq);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x6280
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
leaq -0x98(%rip), %rdi       # 0x32e70
leaq -0x6f(%rip), %rsi       # 0x32ea0
callq 0x48fe0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: pushenv
void
pushenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff < Maxstabdepth);
	envstk[envstkoff++] = env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x32f85
jmp 0x32fd7
cmpq $0x80, 0x4a920(%rip) # 0x7d8b0
jae 0x32f94
jmp 0x32fb3
leaq 0x2044e(%rip), %rdi     # 0x533e9
leaq 0x203f1(%rip), %rsi     # 0x53393
movl $0x9b, %edx
leaq 0x20454(%rip), %rcx     # 0x53402
callq 0x6160
movq -0x8(%rbp), %rdx
movq 0x4a8f2(%rip), %rcx     # 0x7d8b0
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x4a8e4(%rip)     # 0x7d8b0
leaq 0x4a8ed(%rip), %rax     # 0x7d8c0
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: popenv
void
popenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff > 0);
	envstkoff--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x32ff5
jmp 0x33032
cmpq $0x0, 0x4a8b3(%rip)     # 0x7d8b0
jbe 0x33001
jmp 0x33020
leaq 0x20410(%rip), %rdi     # 0x53418
leaq 0x20384(%rip), %rsi     # 0x53393
movl $0xa4, %edx
leaq 0x2040b(%rip), %rcx     # 0x53426
callq 0x6160
movq 0x4a889(%rip), %rax     # 0x7d8b0
addq $-0x1, %rax
movq %rax, 0x4a87e(%rip)     # 0x7d8b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: findstab
Stab *
findstab(Stab *st, Node *n)
{
	Stab *ns;

	if (n->name.ns) {
		ns = getns(n->name.ns);
		if (!ns) {
			ns = mkstab(0);
			updatens(ns, n->name.ns);
		}
		st = ns;
	}
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x33097
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x330b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3308f
xorl %edi, %edi
callq 0x32b90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x330e0
movq -0x18(%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/stab.c
// Function: getclosed
Node *
getclosed(Stab *st, Node *n)
{
	while (st && !st->env)
		st = st->super;
	if (st)
		return htget(st->env, n);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x3335d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x33366
jmp 0x33373
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x33340
cmpq $0x0, -0x10(%rbp)
je 0x33391
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x8(%rbp)
jmp 0x33399
movq $0x0, -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/stab.c
// Function: getclosure
Node **
getclosure(Stab *st, size_t *n)
{
	size_t nkeys, i;
	void **keys;
	Node **vals;

	while (st && !st->env)
		st = st->super;

	if (!st) {
		*n = 0;
		return NULL;
	}

	vals = NULL;
	*n = 0;
	keys = htkeys(st->env, &nkeys);
	for (i = 0; i < nkeys; i++)
		lappend(&vals, n, htget(st->env, keys[i]));
	free(keys);
	return vals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
je 0x333dd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x333e6
jmp 0x333f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x333c0
cmpq $0x0, -0x10(%rbp)
jne 0x33412
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x3349c
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x49720
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3348b
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq -0x48(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x48290
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x33442
movq -0x30(%rbp), %rdi
callq 0x6040
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: getdcl
Node *
getdcl(Stab *start, Node *n)
{
	Stab *st, *fn;
	Node *s;

	fn = NULL;
	st = start;
	do {
		s = htget(st->dcl, n);
		if (s) {
			envclose(start, st, fn, s);
			return s;
		}
		if (!fn && st->env)
			fn = st;
		st = st->super;
	} while (st);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3350b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x33550
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3353f
cmpq $0x0, -0x28(%rbp)
jne 0x33525
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x33525
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x334d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: envclose
static void
envclose(Stab *start, Stab *found, Stab *fn, Node *s)
{
	Stab *st;

	for (st = start; st != found; st = st->super)
		if (st->env && !s->decl.isglobl && !s->decl.isgeneric)
			htput(st->env, s->decl.name, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x335c1
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x335b2
movq -0x20(%rbp), %rax
cmpb $0x0, 0x71(%rax)
jne 0x335b2
movq -0x20(%rbp), %rax
cmpb $0x0, 0x73(%rax)
jne 0x335b2
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x49100
jmp 0x335b4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x33570
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: putlbl
void
putlbl(Stab *st, char *name, Node *lbl)
{
	assert(st && st->isfunc);
	if (hthas(st->lbl, name))
		fatal(lbl, "duplicate label %s, first defined on line %d\n", name, lbl->loc.line);
	htput(st->lbl, name, lbl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x335fa
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x335fa
jmp 0x33619
leaq 0x1fe3a(%rip), %rdi     # 0x5343b
leaq 0x1fd8b(%rip), %rsi     # 0x53393
movl $0x106, %edx            # imm = 0x106
leaq 0x1fe38(%rip), %rcx     # 0x5344c
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x3364b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
leaq 0x1fe2c(%rip), %rsi     # 0x53470
movb $0x0, %al
callq 0x1dfe0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: getlbl
Node *
getlbl(Stab *st, Srcloc loc, char *name)
{
	while (st && !st->isfunc)
		st = st->super;
	if (!st || !hthas(st->lbl, name))
		return NULL;
	return htget(st->lbl, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x336a0
movq -0x18(%rbp), %rax
cmpb $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x336a9
jmp 0x336b6
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x33684
cmpq $0x0, -0x18(%rbp)
je 0x336d3
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
jne 0x336dd
movq $0x0, -0x8(%rbp)
jmp 0x336f2
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x49490
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: gettype
Type *
gettype(Stab *st, Node *n)
{
	Tydefn *t;

	do {
		if ((t = htget(st->ty, n)))
			return t->type;
		st = st->super;
	} while (st);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x33789
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x337a3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x33760
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: hastype
int
hastype(Stab *st, Node *n)
{
	do {
		if (hthas(st->ty, n))
			return 1;
		st = st->super;
	} while (st);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x337df
movl $0x1, -0x4(%rbp)
jmp 0x337f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x337c0
movl $0x0, -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/stab.c
// Function: getucon
Ucon *
getucon(Stab *st, Node *n)
{
	Ucon *uc;

	do {
		if ((uc = htget(st->uc, n)))
			return uc;
		st = st->super;
	} while (st);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x33845
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3385f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x33820
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: gettrait
Trait *
gettrait(Stab *st, Node *n)
{
	Traitdefn *c;

	if (n->name.ns)
		st = getns(n->name.ns);
	do {
		if ((c = htget(st->tr, n)))
			return c->trait;
		st = st->super;
	} while (st);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3389c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x330b0
movq %rax, -0x10(%rbp)
jmp 0x3389e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x338c7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x338e1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3389e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: putdcl
void
putdcl(Stab *st, Node *s)
{
	Node *old;

	st = findstab(st, s->decl.name);
	old = htget(st->dcl, s->decl.name);
	if (!old)
		forcedcl(st, s);
	else if (!mergedecl(old, s))
		fatal(old, "%s already declared on %s:%d", namestr(s->decl.name), fname(s->loc),
				lnum(s->loc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x33040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x49490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x339c4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x338f0
jmp 0x33a2a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33a30
cmpl $0x0, %eax
jne 0x33a28
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x30600
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f0b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl %eax, %r8d
leaq 0x1faf3(%rip), %rsi     # 0x53514
movb $0x0, %al
callq 0x1dfe0
jmp 0x33a2a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: updatetype
void
updatetype(Stab *st, Node *n, Type *t)
{
	Tydefn *td;

	td = htget(st->ty, n);
	if (!td)
		die("no type %s to update", namestr(n));
	td->type = 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), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3402a
movq -0x10(%rbp), %rdi
callq 0x30600
movq %rax, %rsi
leaq 0x1f4be(%rip), %rdi     # 0x534e1
movb $0x0, %al
callq 0x1df20
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: mergetype
int
mergetype(Type *old, Type *new)
{
	if (!new) {
		lfatal(old->loc, "double prototyping of %s", tystr(old));
	} else if (old->vis == Visexport && new->vis != Visexport) {
		if (!old->sub && new->sub) {
			old->sub = new->sub;
			old->nsub = new->nsub;
			return 1;
		}
	} else if (new->vis == Visexport && old->vis != Visexport) {
		if (!new->sub && old->sub) {
			new->sub = old->sub;
			new->nsub = old->nsub;
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x34081
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1f47c(%rip), %rsi     # 0x534f6
movb $0x0, %al
callq 0x1e110
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x340d6
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x340d6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x340d4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x340d4
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x34136
jmp 0x3412d
movq -0x18(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x3412b
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x3412b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x34129
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x34129
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x34136
jmp 0x3412b
jmp 0x3412d
jmp 0x3412f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: puttype
void
puttype(Stab *st, Node *n, Type *t)
{
	Tydefn *td;
	Type *ty;

	st = findstab(st, n);
	setns(n, st->name);
	if (st->name && t && t->name)
		setns(t->name, st->name);

	ty = gettype(st, n);
	if (!ty) {
		if (t && hastype(st, n)) {
			t->vis = Visexport;
			updatetype(st, n, t);
		} else {
			td = xalloc(sizeof(Tydefn));
			td->loc = n->loc;
			td->name = n;
			td->type = t;
			htput(st->ty, td->name, td);
		}
	} else if (!mergetype(ty, t)) {
		fatal(n, "type %s already declared on %s:%d", tystr(ty), fname(ty->loc),
				lnum(ty->loc));
	}
}

// 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
movq -0x10(%rbp), %rsi
callq 0x33040
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2fb60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x341ae
cmpq $0x0, -0x18(%rbp)
je 0x341ae
movq -0x18(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x341ae
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2fb60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33750
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x34250
cmpq $0x0, -0x18(%rbp)
je 0x34201
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x337b0
cmpl $0x0, %eax
je 0x34201
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33fe0
jmp 0x3424e
movl $0x18, %edi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x49100
jmp 0x342b4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34040
cmpl $0x0, %eax
jne 0x342b2
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38a10
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2f090
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2f0b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl %eax, %r8d
leaq 0x1f264(%rip), %rsi     # 0x5350f
movb $0x0, %al
callq 0x1dfe0
jmp 0x342b4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: putucon
void
putucon(Stab *st, Ucon *uc)
{
	Ucon *old;

	old = getucon(st, uc->name);
	if (old)
		lfatal(old->loc, "`%s already defined on %s:%d",
			namestr(uc->name), fname(uc->loc), lnum(uc->loc));
	setns(uc->name, st->name);
	htput(st->uc, uc->name, uc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x33810
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34341
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f0b0
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl %eax, %r8d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x1f1f7(%rip), %rsi     # 0x53531
movb $0x0, %al
callq 0x1e110
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2fb60
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%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/stab.c
// Function: puttrait
void
puttrait(Stab *st, Node *n, Trait *c)
{
	Traitdefn *td;
	Trait *t;
	Type *ty;

	st = findstab(st, n);
	t = gettrait(st, n);
	if (t) {
		if (mergetrait(t, c))
			return;
		fatal(n, "trait %s already defined on %s:%d",
			namestr(n), fname(t->loc), lnum(t->loc));
	}
	ty = gettype(st, n);
	if (ty)
		fatal(n, "trait %s defined as a type on %s:%d",
			namestr(n), fname(ty->loc), lnum(ty->loc));
	td = xalloc(sizeof(Traitdefn));
	td->loc = n->loc;
	td->name = n;
	td->trait = c;
	setns(td->name, st->name);
	htput(st->tr, td->name, td);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33870
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x34424
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34500
cmpl $0x0, %eax
je 0x343d4
jmp 0x344ee
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30600
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x4(%rax), %rdi
callq 0x2f090
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x4(%rax), %rdi
callq 0x2f0b0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl %eax, %r8d
leaq 0x1f131(%rip), %rsi     # 0x5354e
movb $0x0, %al
callq 0x1dfe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33750
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3448c
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30600
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2f090
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2f0b0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl %eax, %r8d
leaq 0x1f0eb(%rip), %rsi     # 0x53570
movb $0x0, %al
callq 0x1dfe0
movl $0x18, %edi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2fb60
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x49100
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: mergetrait
static int
mergetrait(Trait *old, Trait *new)
{
	int hidden;

	hidden = old->ishidden && new->ishidden;
	if (old->isproto && !new->isproto)
		*old = *new;
	else if (new->isproto && !old->isproto)
		*new = *old;
	else if (!new->isimport && !old->isimport)
		if (new->vis == Vishidden || old->vis == Vishidden)
			return 0;
	new->ishidden = hidden;
	old->ishidden = hidden;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x49(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x34533
movq -0x18(%rbp), %rax
movsbl 0x49(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x34569
movq -0x18(%rbp), %rax
cmpb $0x0, 0x48(%rax)
jne 0x34569
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x6260
jmp 0x345cb
movq -0x18(%rbp), %rax
movsbl 0x48(%rax), %eax
cmpl $0x0, %eax
je 0x34594
movq -0x10(%rbp), %rax
cmpb $0x0, 0x48(%rax)
jne 0x34594
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x6260
jmp 0x345c9
movq -0x18(%rbp), %rax
cmpb $0x0, 0x4a(%rax)
jne 0x345c7
movq -0x10(%rbp), %rax
cmpb $0x0, 0x4a(%rax)
jne 0x345c7
movq -0x18(%rbp), %rax
cmpl $0x2, 0xc(%rax)
je 0x345bc
movq -0x10(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x345c5
movl $0x0, -0x4(%rbp)
jmp 0x345ea
jmp 0x345c7
jmp 0x345c9
jmp 0x345cb
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x49(%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x49(%rax)
movl $0x1, -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/stab.c
// Function: putimpl
void
putimpl(Stab *st, Node *n)
{
	Node *impl;

	st = findstab(st, n->impl.traitname);
	impl = getimpl(st, n);
	if (impl && !mergeimpl(impl, n))
		fatal(n, "trait %s already implemented over %s at %s:%d",
			namestr(n->impl.traitname), tystr(n->impl.type),
			fname(n->loc), lnum(n->loc));
	/* if this is not a duplicate, record it for later export */
	if (!impl)
		lappend(&file.impl, &file.nimpl, n);
	/*
	 The impl is not defined in this file, so setting the
	 trait name would be a bug here.
	 */
	setns(n->impl.traitname, st->name);
	htput(st->impl, n, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x33040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34710
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x346b6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34770
cmpl $0x0, %eax
jne 0x346b6
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x30600
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x38a10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2f0b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl %eax, %r9d
leaq 0x1eee5(%rip), %rsi     # 0x53594
movb $0x0, %al
callq 0x1dfe0
cmpq $0x0, -0x18(%rbp)
jne 0x346d8
movq -0x10(%rbp), %rdx
leaq 0x486d0(%rip), %rsi     # 0x7cd98
movq %rsi, %rdi
addq $0x70, %rdi
addq $0x78, %rsi
callq 0x48290
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2fb60
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x49100
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: getimpl
Node *
getimpl(Stab *st, Node *n)
{
	Node *imp;

	do {
		if ((imp = htget(st->impl, n)))
			return imp;
		st = st->super;
	} while (st);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x34745
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3475f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x34720
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: mergeimpl
static int
mergeimpl(Node *old, Node *new)
{
	Vis vis;

	/* extern traits should be deduped in use.c. */
	if (old->impl.isextern && new->impl.isextern)
		return 1;
	if (old->impl.vis > new->impl.vis)
		vis = old->impl.vis;
	else
		vis = new->impl.vis;
	old->impl.vis = vis;
	new->impl.vis = vis;
	if (old->impl.isproto && !new->impl.isproto)
		*old = *new;
	else if (new->impl.isproto && !old->impl.isproto)
		*new = *old;
	else
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x5d(%rax), %eax
cmpl $0x0, %eax
je 0x347a6
movq -0x18(%rbp), %rax
movsbl 0x5d(%rax), %eax
cmpl $0x0, %eax
je 0x347a6
movl $0x1, -0x4(%rbp)
jmp 0x34848
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jbe 0x347c2
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x347cc
movq -0x18(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x0, %eax
je 0x3480b
movq -0x18(%rbp), %rax
cmpb $0x0, 0x5c(%rax)
jne 0x3480b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x80, %edx
callq 0x6260
jmp 0x34841
movq -0x18(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x0, %eax
je 0x34836
movq -0x10(%rbp), %rax
cmpb $0x0, 0x5c(%rax)
jne 0x34836
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x80, %edx
callq 0x6260
jmp 0x3483f
movl $0x0, -0x4(%rbp)
jmp 0x34848
jmp 0x34841
movl $0x1, -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/stab.c
// Function: putns
void
putns(Stab *scope)
{
	Stab *s;

	s = getns(scope->name);
	if (s)
		lfatal(Zloc, "Namespace %s already defined", scope->name);
	htput(file.ns, scope->name, scope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x330b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348ac
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rdi
leaq 0x1ed1d(%rip), %rsi     # 0x535c2
movb $0x0, %al
callq 0x1e110
leaq 0x484e5(%rip), %rax     # 0x7cd98
movq 0xa0(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rdx
callq 0x49100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: bindtype
void
bindtype(Tyenv *env, Type *t)
{
	Bitset *visited;

	if (!t || !env)
		return;
	visited = mkbs();
	bindtype_rec(env, t, visited);
	bsfree(visited);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348fe
cmpq $0x0, -0x8(%rbp)
jne 0x34900
jmp 0x34923
callq 0x48650
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x34930
movq -0x18(%rbp), %rdi
callq 0x48690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/stab.c
// Function: boundtype
Type*
boundtype(Type *t)
{
	Tyenv *e;
	Type *r;

	if (t->type != Typaram)
		return NULL;
	for (e = curenv(); e; e = e->super) {
		r = htget(e->tab, t);
		if (r)
			return r;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1a, (%rax)
je 0x34caf
movq $0x0, -0x8(%rbp)
jmp 0x34cfc
callq 0x32f30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34cf4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x34ce5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x34cfc
jmp 0x34ce7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x34cb8
movq $0x0, -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/tok.c
// Function: toknext
static Tok *
toknext(void)
{
	Tok *t;
	int c;

	eatspace();
	c = peek();
	if (c == End) {
		t = mktok(0);
	} else if (c == '\n') {
		curloc.line++;
		next();
		t = mktok(Tendln);
	} else if (isalpha(c) || c == '_' || c == '$') {
		t = kwident();
	} else if (c == '"') {
		t = strlit();
	} else if (c == '\'') {
		t = charlit();
	} else if (isdigit(c)) {
		t = numlit();
	} else if (c == '@') {
		t = typaram();
	} else {
		t = oper();
	}

	if (!t)
		lfatal(curloc, "Unable to parse token starting with %c", c);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x35130
callq 0x35240
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x34fab
xorl %edi, %edi
callq 0x35250
movq %rax, -0x8(%rbp)
jmp 0x35076
cmpl $0xa, -0xc(%rbp)
jne 0x34fd8
movl 0x48d15(%rip), %eax     # 0x7dccc
addl $0x1, %eax
movl %eax, 0x48d0c(%rip)     # 0x7dccc
callq 0x35290
movl $0x147, %edi            # imm = 0x147
callq 0x35250
movq %rax, -0x8(%rbp)
jmp 0x35074
callq 0x6370
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x34ffe
cmpl $0x5f, -0xc(%rbp)
je 0x34ffe
cmpl $0x24, -0xc(%rbp)
jne 0x35009
callq 0x352c0
movq %rax, -0x8(%rbp)
jmp 0x35072
cmpl $0x22, -0xc(%rbp)
jne 0x3501a
callq 0x35340
movq %rax, -0x8(%rbp)
jmp 0x35070
cmpl $0x27, -0xc(%rbp)
jne 0x3502b
callq 0x35460
movq %rax, -0x8(%rbp)
jmp 0x3506e
callq 0x6370
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x35050
callq 0x35590
movq %rax, -0x8(%rbp)
jmp 0x3506c
cmpl $0x40, -0xc(%rbp)
jne 0x35061
callq 0x35640
movq %rax, -0x8(%rbp)
jmp 0x3506a
callq 0x356d0
movq %rax, -0x8(%rbp)
jmp 0x3506c
jmp 0x3506e
jmp 0x35070
jmp 0x35072
jmp 0x35074
jmp 0x35076
cmpq $0x0, -0x8(%rbp)
jne 0x35095
movl -0xc(%rbp), %edx
movq 0x48c45(%rip), %rdi     # 0x7dccc
leaq 0x1ea82(%rip), %rsi     # 0x53b10
movb $0x0, %al
callq 0x1e110
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop