LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkdecl
Node *
mkdecl(Srcloc loc, Node *name, Type *ty)
{
	Node *n;

	n = mknode(loc, Ndecl);
	n->decl.did = ndecls;
	n->decl.name = name;
	n->decl.type = ty;
	lappend(&decls, &ndecls, n);
	if (ty && hasparams(ty)) {
		n->decl.env = mkenv();
		bindtype(n->decl.env, ty);
	}

	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r14
leaq 0x438d4(%rip), %rsi     # 0x61948
movl 0x438ce(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0xb, 0x8(%r14)
movq %r12, (%r14)
leaq 0x438c0(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2ceff
leaq 0x438c1(%rip), %rsi     # 0x61960
movq 0x438ba(%rip), %rax     # 0x61960
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x438af(%rip), %rdi     # 0x61968
movq %r14, %rdx
callq 0x2ceff
testq %rbx, %rbx
je 0x1e0e6
movq %rbx, %rdi
callq 0x231e7
testl %eax, %eax
je 0x1e0e6
callq 0x1fecc
movq %rax, 0x38(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20d76
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: gentemp
Node *
gentemp(Srcloc loc, Type *ty, Node **dcl)
{
	char buf[128];
	static int nexttmp;
	Node *t, *r, *n;

	bprintf(buf, 128, ".t%d", nexttmp++);
	n = mkname(loc, buf);
	t = mkdecl(loc, n, ty);
	r = mkexpr(loc, Ovar, n, NULL);
	r->expr.type = t->decl.type;
	r->expr.did = t->decl.did;
	if (dcl)
		*dcl = t;
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x4385e(%rip), %ecx     # 0x61970
leal 0x1(%rcx), %eax
movl %eax, 0x43855(%rip)     # 0x61970
leaq 0x18e46(%rip), %rdx     # 0x36f68
movq %rsp, %r12
movl $0x80, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2dfae
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d6f5
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1e04f
movq %rax, %r15
movq %r14, %rdi
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x38(%rax)
testq %rbx, %rbx
je 0x1e17f
movq %r15, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkucon
Ucon *
mkucon(Srcloc loc, Node *name, Type *ut, Type *et)
{
	Ucon *uc;

	uc = zalloc(sizeof(Ucon));
	uc->loc = loc;
	uc->name = name;
	uc->utype = ut;
	uc->etype = et;
	return uc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x30, %edi
callq 0x2ce48
movq %r12, (%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkbool
Node *
mkbool(Srcloc loc, int val)
{
	Node *n;

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

	return n;
}

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2ce48
movq %rax, %r14
leaq 0x4370d(%rip), %rsi     # 0x61948
movl 0x43707(%rip), %eax     # 0x61948
movl %eax, 0xc(%r14)
movl $0x9, 0x8(%r14)
movq %rbx, (%r14)
leaq 0x436f9(%rip), %rdi     # 0x61950
movq %r14, %rdx
callq 0x2ceff
movl $0x1, 0x18(%r14)
movl %ebp, 0x30(%r14)
movq %rbx, %rdi
movl $0x35, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2289d
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: mkvoid
Node *
mkvoid(Srcloc loc)
{
	Node *n;

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

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

// Assembly:
cmpl $0xb, 0x8(%rdi)
jne 0x1e2fc
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rax
retq
pushq %rax
leaq 0x18c69(%rip), %rdi     # 0x36f6d
leaq 0x18c01(%rip), %rsi     # 0x36f0c
leaq 0x18c6c(%rip), %rcx     # 0x36f7e
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: litvaleq
int
litvaleq(Node *a, Node *b)
{
	assert(a->type == Nlit && b->type == Nlit);
	if (a->lit.littype != b->lit.littype)
		return 0;
	switch (a->lit.littype) {
	case Lvoid:	return 1;
	case Lchr:	return a->lit.chrval == b->lit.chrval;
	case Lbool:	return a->lit.boolval == b->lit.boolval;
	case Lint:	return a->lit.intval == b->lit.intval;
	case Lflt:	return a->lit.fltval == b->lit.fltval;
	case Lstr:
			return a->lit.strval.len == b->lit.strval.len &&
				!memcmp(a->lit.strval.buf, b->lit.strval.buf, a->lit.strval.len);
	case Lfunc:	return a->lit.fnval == b->lit.fnval;
	case Llbl:	return !strcmp(a->lit.lblval, b->lit.lblval);	break;
	}
	return 0;
}

// Assembly:
pushq %rax
cmpl $0x9, 0x8(%rdi)
jne 0x1e472
cmpl $0x9, 0x8(%rsi)
jne 0x1e472
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x1e457
cmpl $0x7, %eax
ja 0x1e457
movl %eax, %eax
leaq 0x18a72(%rip), %rcx     # 0x36e7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x30(%rdi), %eax
cmpl 0x30(%rsi), %eax
jmp 0x1e46a
movq 0x30(%rdi), %rax
cmpq 0x30(%rsi), %rax
jmp 0x1e46a
movsd 0x30(%rsi), %xmm0
cmpeqsd 0x30(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1e46d
movb $0x1, %al
jmp 0x1e46d
movq 0x30(%rdi), %rdx
cmpq 0x30(%rsi), %rdx
jne 0x1e457
movq 0x38(%rdi), %rdi
movq 0x38(%rsi), %rsi
callq 0x4290
jmp 0x1e468
xorl %eax, %eax
jmp 0x1e46d
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
callq 0x4230
testl %eax, %eax
sete %al
movzbl %al, %eax
popq %rcx
retq
leaq 0x18b5e(%rip), %rdi     # 0x36fd7
leaq 0x18a8c(%rip), %rsi     # 0x36f0c
leaq 0x18b73(%rip), %rcx     # 0x36ffa
movl $0x204, %edx            # imm = 0x204
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: namestr
char *
namestr(Node *name)
{
	if (!name)
		return "";
	assert(name->type == Nname);
	return name->name.name;
}

// Assembly:
testq %rdi, %rdi
je 0x1e4fb
cmpl $0xa, 0x8(%rdi)
jne 0x1e503
movq 0x20(%rdi), %rax
retq
leaq 0x13948(%rip), %rax     # 0x31e4a
retq
pushq %rax
leaq 0x18b67(%rip), %rdi     # 0x37072
leaq 0x189fa(%rip), %rsi     # 0x36f0c
leaq 0x18b6d(%rip), %rcx     # 0x37086
movl $0x240, %edx            # imm = 0x240
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: nameeq
int
nameeq(void *p1, void *p2)
{
	Node *a, *b;
	a = p1;
	b = p2;
	if (a == b)
		return 1;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x1e57c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x13911(%rip), %rsi     # 0x31e4a
movq %rsi, %rdi
testq %r14, %r14
je 0x1e54c
cmpl $0xa, 0x8(%r14)
jne 0x1e58d
movq 0x20(%r14), %rdi
testq %rbx, %rbx
je 0x1e55b
cmpl $0xa, 0x8(%rbx)
jne 0x1e58d
movq 0x20(%rbx), %rsi
callq 0x2db3b
testl %eax, %eax
je 0x1e583
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x2db3b
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x1e585
movl $0x1, %eax
jmp 0x1e585
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18ade(%rip), %rdi     # 0x37072
leaq 0x18971(%rip), %rsi     # 0x36f0c
leaq 0x18ae4(%rip), %rcx     # 0x37086
movl $0x240, %edx            # imm = 0x240
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: lblstr
char *
lblstr(Node *n)
{
	assert(exprop(n) == Olit);
	assert(n->expr.args[0]->type == Nlit);
	assert(n->expr.args[0]->lit.littype == Llbl);
	return n->expr.args[0]->lit.lblval;
}

// Assembly:
pushq %rax
cmpl $0x8, 0x8(%rdi)
jne 0x1e5d2
cmpl $0x35, 0x18(%rdi)
jne 0x1e5f1
movq 0x50(%rdi), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x1e610
cmpl $0x6, 0x18(%rax)
jne 0x1e62f
movq 0x30(%rax), %rax
popq %rcx
retq
leaq 0x1277f(%rip), %rdi     # 0x30d58
leaq 0x1892c(%rip), %rsi     # 0x36f0c
leaq 0x18a79(%rip), %rcx     # 0x37060
movl $0x237, %edx            # imm = 0x237
callq 0x4180
leaq 0x18aa4(%rip), %rdi     # 0x3709c
leaq 0x1890d(%rip), %rsi     # 0x36f0c
leaq 0x18aa8(%rip), %rcx     # 0x370ae
movl $0x247, %edx            # imm = 0x247
callq 0x4180
leaq 0x18aac(%rip), %rdi     # 0x370c3
leaq 0x188ee(%rip), %rsi     # 0x36f0c
leaq 0x18a89(%rip), %rcx     # 0x370ae
movl $0x248, %edx            # imm = 0x248
callq 0x4180
leaq 0x18aab(%rip), %rdi     # 0x370e1
leaq 0x188cf(%rip), %rsi     # 0x36f0c
leaq 0x18a6a(%rip), %rcx     # 0x370ae
movl $0x249, %edx            # imm = 0x249
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/node.c
// Function: did
static size_t
did(Node *n)
{
	if (n->type == Ndecl) {
		return n->decl.did;
	} else if (n->type == Nexpr) {
		assert(exprop(n) == Ovar);
		return n->expr.did;
	}
	dumpn(n, stderr);
	die("Can't get did");
	return 0;
}

// Assembly:
pushq %rax
movl 0x8(%rdi), %ecx
movl $0x18, %eax
cmpl $0xb, %ecx
je 0x1e67b
cmpl $0x8, %ecx
jne 0x1e681
movl $0x38, %eax
cmpl $0x33, 0x18(%rdi)
jne 0x1e69e
movq (%rdi,%rax), %rax
popq %rcx
retq
movq 0x25968(%rip), %rax     # 0x43ff0
movq (%rax), %rsi
callq 0x13806
leaq 0x18a94(%rip), %rdi     # 0x3712b
xorl %eax, %eax
callq 0x13844
leaq 0x18a61(%rip), %rdi     # 0x37106
leaq 0x18860(%rip), %rsi     # 0x36f0c
leaq 0x18a65(%rip), %rcx     # 0x37118
movl $0x253, %edx            # imm = 0x253
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/specialize.c
// Function: substget
Type *
substget(Tysubst *subst, Type *from)
{
	Type *t;
	size_t i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x1e72e
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x1e732
decq %r12
jne 0x1e712
jmp 0x1e735
xorl %ebx, %ebx
jmp 0x1e735
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/specialize.c
// Function: substfree
void
substfree(Tysubst *subst)
{
	size_t i;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
cmpq $0x0, 0x8(%rdi)
je 0x1e7b0
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x2d6e7
incq %r15
cmpq 0x8(%r14), %r15
jb 0x1e79b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2d0c7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/specialize.c
// Function: genericname
Node *
genericname(Node *n, Type *param, Type *t)
{
	char buf[1024];
	char *p;
	char *end;
	Node *name;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
cmpb $0x0, 0x73(%rdi)
je 0x1f27e
movq %rdx, %r14
movq %rsi, %r12
leaq 0x400(%rsp), %r15
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rcx
leaq 0x178f0(%rip), %rdx     # 0x36acd
movq %rsp, %rdi
movl $0x400, %ebp            # imm = 0x400
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x2dfae
leaq (%rsp,%rax), %r13
testq %r12, %r12
je 0x1f22e
subq %rax, %rbp
leaq 0x10071(%rip), %rdx     # 0x2f275
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2dfae
movq %rax, %rbp
addq %r13, %rbp
movq %r15, %rsi
subq %rbp, %rsi
movq %rbp, %rdi
movq %r12, %rdx
callq 0x2409c
movq %rax, %r13
addq %rbp, %r13
movq %r15, %rsi
subq %r13, %rsi
leaq 0x1003a(%rip), %rdx     # 0x2f275
movq %r13, %rdi
xorl %eax, %eax
callq 0x2dfae
addq %rax, %r13
subq %r13, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2409c
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x1d6f5
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x1f282
movq %r14, %rdi
callq 0x1dcb0
jmp 0x1f282
movq 0x20(%rbx), %r14
movq %r14, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%rsi), %rdx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x33, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r13
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2d, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %r14, 0x20(%r13)
movq %r15, 0x20(%rax)
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%r13)
movl $0x1, 0x30(%r13)
leaq 0x28(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2ceff
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x90, %edi
callq 0x2ce48
movq %rax, %r14
leaq -0x6b(%rip), %r15       # 0x1fc84
leaq -0x63(%rip), %r12       # 0x1fc93
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d678
movq %rax, 0x18(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d678
movq %rax, 0x28(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d678
movq %rax, 0x30(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d678
movq %rax, 0x38(%r14)
testl %ebx, %ebx
je 0x1fd64
leaq -0xb9(%rip), %rdi       # 0x1fc84
leaq -0xb1(%rip), %rsi       # 0x1fc93
callq 0x2d678
movq %rax, 0x20(%r14)
leaq 0xdd3f(%rip), %rdi      # 0x2da93
leaq 0xdde0(%rip), %rsi      # 0x2db3b
callq 0x2d678
movq %rax, 0x40(%r14)
leaq 0x23(%rip), %rdi        # 0x1fd8e
leaq 0x4c(%rip), %rsi        # 0x1fdbe
callq 0x2d678
movq %rax, 0x48(%r14)
movb %bl, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1e4eb
movq %rax, %rdi
callq 0x2da93
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x239d8
imulq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl $0x10, %edi
callq 0x4280
movq %rax, %rbx
movq $0x0, (%rax)
leaq -0x3b(%rip), %rdi       # 0x1fead
leaq -0x36(%rip), %rsi       # 0x1feb9
callq 0x2d678
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/stab.c
// Function: pushenv
void
pushenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff < Maxstabdepth);
	envstk[envstkoff++] = env;
}

// Assembly:
testq %rdi, %rdi
je 0x1ff43
movq 0x41e6b(%rip), %rax     # 0x61d90
cmpq $0x80, %rax
jae 0x1ff44
leaq 0x1(%rax), %rcx
movq %rcx, 0x41e58(%rip)     # 0x61d90
leaq 0x41e61(%rip), %rcx     # 0x61da0
movq %rdi, (%rcx,%rax,8)
retq
pushq %rax
leaq 0x174a9(%rip), %rdi     # 0x373f5
leaq 0x1744c(%rip), %rsi     # 0x3739f
leaq 0x174b4(%rip), %rcx     # 0x3740e
movl $0x9b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/stab.c
// Function: popenv
void
popenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff > 0);
	envstkoff--;
}

// Assembly:
testq %rdi, %rdi
je 0x1ff7f
movq 0x41e20(%rip), %rax     # 0x61d90
testq %rax, %rax
je 0x1ff80
decq %rax
movq %rax, 0x41e11(%rip)     # 0x61d90
retq
pushq %rax
leaq 0x1749c(%rip), %rdi     # 0x37424
leaq 0x17410(%rip), %rsi     # 0x3739f
leaq 0x1749c(%rip), %rcx     # 0x37432
movl $0xa4, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x1ffe4
leaq 0x412be(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
callq 0x2d8fa
movq %rax, %r14
testq %rax, %rax
jne 0x1ffe4
xorl %edi, %edi
callq 0x1fcd1
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x20005
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/stab.c
// Function: updatens
void
updatens(Stab *st, char *name)
{
	void **k;
	size_t i, nk;
	Traitdefn *tr;
	Tydefn *td;

	if (st->name)
		die("stab %s already has namespace; Can't set to %s", st->name, name);
	st->name = strdup(name);
	htput(file.ns, st->name, st);

	k = htkeys(st->dcl, &nk);
	for (i = 0; i < nk; i++)
		setns(k[i], name);
	free(k);

	k = htkeys(st->ty, &nk);
	for (i = 0; i < nk; i++)
		setns(k[i], name);
	for (i = 0; i < nk; i++) {
		td = htget(st->ty, k[i]);
		if (td->type && (td->type->type == Tyname || td->type->type == Tygeneric))
			setns(td->type->name, name);
	}
	free(k);

	k = htkeys(st->tr, &nk);
	for (i = 0; i < nk; i++) {
		tr = htget(st->tr, k[i]);
		setns(tr->name, name);
	}
	free(k);

	k = htkeys(st->uc, &nk);
	for (i = 0; i < nk; i++)
		setns(k[i], name);
	free(k);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
jne 0x20184
movq %rdi, %r14
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x8(%r14)
leaq 0x41245(%rip), %rcx     # 0x61278
movq 0xa0(%rcx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2d71e
movq 0x18(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2da36
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x20076
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1dcb0
incq %r12
cmpq (%rsp), %r12
jb 0x20061
movq %r15, %rdi
callq 0x4040
movq 0x28(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2da36
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x200f2
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1dcb0
incq %r12
movq (%rsp), %rax
cmpq %rax, %r12
jb 0x2009a
testq %rax, %rax
je 0x200f2
xorl %r12d, %r12d
movq 0x28(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2d8fa
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x200e9
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x1c, %ecx
jne 0x200e9
movq 0x88(%rax), %rdi
movq %rbx, %rsi
callq 0x1dcb0
incq %r12
cmpq (%rsp), %r12
jb 0x200ba
movq %r15, %rdi
callq 0x4040
movq 0x30(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2da36
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x20138
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2d8fa
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x1dcb0
incq %r12
cmpq (%rsp), %r12
jb 0x20116
movq %r15, %rdi
callq 0x4040
movq 0x38(%r14), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x2da36
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x20170
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1dcb0
incq %r15
cmpq (%rsp), %r15
jb 0x2015b
movq %r14, %rdi
callq 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17460(%rip), %rdi     # 0x375eb
movq %rbx, %rdx
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x201a8
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x201ab
movq (%rdi), %rdi
jmp 0x20195
xorl %eax, %eax
retq
movq %rax, %rdi
jmp 0x2d8fa
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x201dc
movq %rdi, %r14
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x201e8
movq (%r14), %r14
testq %r14, %r14
jne 0x201cb
movq $0x0, (%rbx)
xorl %r12d, %r12d
jmp 0x2023f
xorl %r12d, %r12d
movq %r12, (%rsp)
movq %r12, (%rbx)
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0x2da36
movq %rax, %r15
cmpq %r12, (%r13)
je 0x20237
xorl %r13d, %r13d
movq %rsp, %r12
movq 0x20(%r14), %rdi
movq (%r15,%r13,8), %rsi
callq 0x2d8fa
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2ceff
incq %r13
cmpq 0x8(%rsp), %r13
jb 0x2020e
movq (%rsp), %r12
movq %r15, %rdi
callq 0x4040
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rdi, %r12
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x2d8fa
movq %rax, %r14
testq %rax, %rax
jne 0x20281
movq (%r12), %r12
testq %r12, %r12
jne 0x20261
jmp 0x202b1
cmpq %rbx, %r12
je 0x202b1
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x202a9
cmpb $0x0, 0x71(%r14)
jne 0x202a9
cmpb $0x0, 0x73(%r14)
jne 0x202a9
movq 0x20(%r14), %rsi
movq %r14, %rdx
callq 0x2d71e
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x20286
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x202fa
movq %rdi, %r15
cmpb $0x0, 0x10(%rdi)
je 0x202fa
movq %rdx, %r14
movq %rsi, %rbx
movq 0x40(%r15), %rdi
callq 0x2da24
testl %eax, %eax
jne 0x20319
movq 0x40(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2d71e
leaq 0x17146(%rip), %rdi     # 0x37447
leaq 0x17097(%rip), %rsi     # 0x3739f
leaq 0x17149(%rip), %rcx     # 0x37458
movl $0x106, %edx            # imm = 0x106
callq 0x4180
movl (%r14), %ecx
leaq 0x17159(%rip), %rsi     # 0x3747c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20373
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%r14)
jne 0x20350
movq (%r14), %r14
testq %r14, %r14
jne 0x2033f
jmp 0x20373
movq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x2da24
testl %eax, %eax
je 0x20373
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d8fa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x203be
movq (%r15), %r15
testq %r15, %r15
jne 0x203a3
jmp 0x203c2
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x20453
leaq 0x40e34(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
callq 0x2d8fa
movq %rax, %r14
xorl %r15d, %r15d
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x20471
movq (%r14), %r14
testq %r14, %r14
jne 0x20456
jmp 0x20475
movq 0x10(%rax), %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x28(%rdi), %rdi
callq 0x2d8fa
testq %rax, %rax
je 0x20812
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x1e4eb
leaq 0x16ccc(%rip), %rdi     # 0x374ed
movq %rax, %rsi
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2088d
cmpl $0x1, 0x10(%rbx)
movl 0x10(%rsi), %ecx
jne 0x2085d
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x2088b
cmpq $0x0, 0x68(%rbx)
jne 0x2088b
movq 0x68(%rsi), %rcx
testq %rcx, %rcx
je 0x2088b
movq %rcx, 0x68(%rbx)
movq %rsi, %rax
jmp 0x2087e
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x2088b
cmpq $0x0, 0x68(%rsi)
jne 0x2088b
movq 0x68(%rbx), %rcx
testq %rcx, %rcx
je 0x2088b
movq %rcx, 0x68(%rsi)
movq %rbx, %rax
movq %rsi, %rbx
movq 0x70(%rax), %rax
movq %rax, 0x70(%rbx)
movl $0x1, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x2398e
movq 0x8(%rbx), %rdi
leaq 0x16c62(%rip), %rsi     # 0x37502
movq %rax, %rdx
xorl %eax, %eax
callq 0x139d2
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0x1ffa0
movq %rax, %r15
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x1dcb0
movq 0x8(%r15), %rsi
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x208f1
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x208f1
callq 0x1dcb0
movq %r15, %r12
movq 0x28(%r12), %rdi
movq %rbx, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x20911
movq (%r12), %r12
testq %r12, %r12
jne 0x208f4
jmp 0x20939
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x20939
movq %r12, %rdi
movq %r14, %rsi
callq 0x2082b
testl %eax, %eax
je 0x209ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r14, %r14
je 0x2095b
movq %r15, %r12
movq 0x28(%r12), %rdi
movq %rbx, %rsi
callq 0x2da24
testl %eax, %eax
jne 0x2098d
movq (%r12), %r12
testq %r12, %r12
jne 0x20941
movl $0x18, %edi
callq 0x2ce79
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x28(%r15), %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2d71e
movl $0x1, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x207ee
movq %r12, %rdi
callq 0x2398e
movq %rax, %r14
movq 0x8(%r12), %rdi
callq 0x1d31c
movq %rax, %r15
movq 0x8(%r12), %rdi
callq 0x1d330
leaq 0x16b44(%rip), %rsi     # 0x3751b
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r12
movq %rdi, %r13
movq 0x38(%r13), %rdi
movq %r12, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x20a40
movq (%r13), %r13
testq %r13, %r13
jne 0x20a00
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x1dcb0
movq 0x38(%r14), %rdi
movq 0x18(%rbx), %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2d71e
movq %rax, %r15
movq 0x18(%rbx), %rdi
callq 0x1e4eb
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1d31c
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1d330
movq (%r15), %rdi
leaq 0x16ad1(%rip), %rsi     # 0x3753d
movq %r14, %rdx
movq %r12, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x139d2
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
callq 0x1ffa0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20429
testq %rax, %rax
je 0x20ab6
movq %rax, %r15
cmpb $0x0, 0x49(%rax)
je 0x20ad4
cmpb $0x0, 0x49(%r14)
setne %al
jmp 0x20ad6
movq %r12, %r15
movq 0x28(%r15), %rdi
movq %rbx, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x20b3c
movq (%r15), %r15
testq %r15, %r15
jne 0x20ab9
jmp 0x20b45
xorl %eax, %eax
cmpb $0x0, 0x48(%r15)
movb 0x48(%r14), %cl
je 0x20af2
testb %cl, %cl
jne 0x20b06
movl $0xa, %ecx
movq %r15, %rdi
movq %r14, %rsi
jmp 0x20b01
testb %cl, %cl
je 0x20b06
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x20b2a
cmpb $0x0, 0x4a(%r14)
jne 0x20b2a
cmpb $0x0, 0x4a(%r15)
jne 0x20b2a
cmpl $0x2, 0xc(%r14)
je 0x20bb9
cmpl $0x2, 0xc(%r15)
je 0x20bb9
movb %al, 0x49(%r14)
movb %al, 0x49(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%rax), %r13
testq %r13, %r13
jne 0x20b87
movl $0x18, %edi
callq 0x2ce79
movq %rax, %r15
movq (%rbx), %rax
movq %rax, (%r15)
movq %rbx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x1dcb0
movq 0x30(%r12), %rdi
movq 0x8(%r15), %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2d71e
movq %rbx, %rdi
callq 0x1e4eb
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x1d31c
movq %rax, %r15
movq 0x8(%r13), %rdi
callq 0x1d330
leaq 0x169ce(%rip), %rsi     # 0x3757c
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
jmp 0x20be9
movq %rbx, %rdi
callq 0x1e4eb
movq %rax, %r14
movq 0x4(%r15), %rdi
callq 0x1d31c
movq %rax, %r12
movq 0x4(%r15), %rdi
callq 0x1d330
leaq 0x1697a(%rip), %rsi     # 0x3755a
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rsi), %rsi
callq 0x1ffa0
movq %rax, %r14
movq %rax, %r15
movq 0x48(%r15), %rdi
movq %rbx, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x20c3f
movq (%r15), %r15
testq %r15, %r15
jne 0x20c0d
leaq 0x4064b(%rip), %rsi     # 0x61278
leaq 0x70(%rsi), %rdi
addq $0x78, %rsi
movq %rbx, %rdx
callq 0x2ceff
jmp 0x20c88
cmpb $0x0, 0x5d(%rax)
je 0x20c4b
cmpb $0x0, 0x5d(%rbx)
jne 0x20c88
movl 0x58(%rax), %ecx
movl 0x58(%rbx), %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
movl %edx, 0x58(%rax)
movl %edx, 0x58(%rbx)
cmpb $0x0, 0x5c(%rax)
movb 0x5c(%rbx), %cl
je 0x20c76
testb %cl, %cl
jne 0x20caf
movl $0x10, %ecx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x20c85
testb %cl, %cl
je 0x20caf
movl $0x10, %ecx
movq %rbx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x1dcb0
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2d71e
movq 0x18(%rbx), %rdi
callq 0x1e4eb
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x2398e
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1d31c
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1d330
leaq 0x168bf(%rip), %rsi     # 0x375a0
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x40544(%rip), %r14     # 0x61278
movq 0xa0(%r14), %rdi
callq 0x2d8fa
testq %rax, %rax
jne 0x20d5f
movq 0xa0(%r14), %rdi
movq 0x8(%rbx), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d71e
movq 0x8(%rbx), %rdx
leaq 0x16864(%rip), %rsi     # 0x375ce
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x139d2
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x20db4
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d13c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20db5
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2d164
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x1a, (%rdi)
jne 0x21065
movq 0x40d6b(%rip), %rax     # 0x61d90
testq %rax, %rax
je 0x21065
pushq %r14
pushq %rbx
pushq %rax
leaq 0x40d6b(%rip), %rcx     # 0x61da0
movq -0x8(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x2105b
movq %rdi, %rbx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2d8fa
testq %rax, %rax
jne 0x2105d
movq (%r14), %r14
testq %r14, %r14
jne 0x21042
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: tokinit
void
tokinit(char *file)
{
	int fd;
	int n;
	int nread;

	fd = open(file, O_RDONLY);
	if (fd == -1) {
		fprintf(stderr, "Unable to open file %s\n", file);
		exit(1);
	}

	nread = 0;
	fbuf = malloc(4096);
	while (1) {
		n = read(fd, fbuf + nread, 4096);
		if (n < 0)
			fatal(0, 0, "Error reading file %s", file);
		if (n == 0)
			break;
		if (!fbuf)
			die("Out of memory reading %s", file);
		nread += n;
		fbuf = xrealloc(fbuf, nread + 4096);
	}

	fbufsz = nread;
	curloc.line = 1;
	curloc.file = 0;
	close(fd);
	if(fbufsz > 2 && fbuf[0] == '#' && fbuf[1] == '!') {
		for (fidx = 0; fidx < fbufsz; fidx++)  {
			if(fbuf[fidx] == '\n') {
				curloc.line++;
				fidx++;
				break;
			}
		}
	}
	filename = strdup(file);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x42d0
cmpl $-0x1, %eax
je 0x2117e
movl %eax, %ebp
movl $0x1000, %edi           # imm = 0x1000
callq 0x4280
movq %rax, 0x4110c(%rip)     # 0x621a0
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %rax, %rsi
callq 0x4200
testl %eax, %eax
js 0x210ed
xorl %ecx, %ecx
testl %eax, %eax
je 0x21102
movq 0x410ec(%rip), %rdi     # 0x621a0
testq %rdi, %rdi
je 0x2116d
leal (%rax,%rcx), %r14d
leal (%rax,%rcx), %esi
addl $0x1000, %esi           # imm = 0x1000
callq 0x2ced6
movq %rax, 0x410ca(%rip)     # 0x621a0
leaq (%r14,%rax), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x4200
movl %r14d, %ecx
testl %eax, %eax
jns 0x210a9
leaq 0x16710(%rip), %rdx     # 0x37804
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x138e7
movl %ecx, 0x410a0(%rip)     # 0x621a8
movq $0x1, 0x4109d(%rip) # 0x621b0
movl %ebp, %edi
callq 0x41e0
movl 0x41088(%rip), %eax     # 0x621a8
cmpl $0x3, %eax
jl 0x21159
movq 0x41074(%rip), %rdx     # 0x621a0
cmpb $0x23, (%rdx)
jne 0x21159
cmpb $0x21, 0x1(%rdx)
jne 0x21159
xorl %ecx, %ecx
cmpb $0xa, (%rdx,%rcx)
je 0x2114b
incq %rcx
cmpq %rcx, %rax
jne 0x21139
movl %eax, %ecx
jmp 0x21153
incl 0x4105f(%rip)           # 0x621b0
incl %ecx
movl %ecx, 0x4105f(%rip)     # 0x621b8
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x41058(%rip)     # 0x621c0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x166a6(%rip), %rdi     # 0x3781a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x13844
movq %rbx, %rdi
callq 0x475b
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: yyerror
void
yyerror(const char *s)
{
	fprintf(stderr, "%s:%d: %s", filename, curloc.line, s);
	if (curtok->id)
		fprintf(stderr, " near \"%s\"", curtok->id);
	fprintf(stderr, "\n");
	exit(1);
}

// Assembly:
pushq %rbx
movq %rdi, %r8
movq 0x2277a(%rip), %rbx     # 0x43ff0
movq (%rbx), %rdi
movq 0x40940(%rip), %rdx     # 0x621c0
movl 0x4092a(%rip), %ecx     # 0x621b0
leaq 0x15fa6(%rip), %rsi     # 0x37833
xorl %eax, %eax
callq 0x4240
movq 0x4092d(%rip), %rax     # 0x621c8
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x218b5
movq (%rbx), %rdi
leaq 0x15f8f(%rip), %rsi     # 0x3783d
xorl %eax, %eax
callq 0x4240
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x41f0
movl $0x1, %edi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: numlit
static int
peekn(int n)
{
	if (fidx + n >= fbufsz)
		return End;
	else
		return fbuf[fidx + n];
}

// Assembly:
movslq 0x408e5(%rip), %rax     # 0x621b8
movl 0x408cf(%rip), %edx     # 0x621a8
movl $0xa, %edi
cmpl %edx, %eax
jge 0x222f5
movq 0x408b3(%rip), %rcx     # 0x621a0
cmpb $0x30, (%rcx,%rax)
jne 0x222f5
leaq 0x1(%rax), %rsi
cmpl %edx, %esi
jge 0x21930
movl $0x10, %edx
cmpb $0x78, (%rcx,%rsi)
je 0x21920
movl $0x2, %edx
cmpb $0x62, (%rcx,%rsi)
je 0x21920
movl $0x8, %edx
cmpb $0x6f, (%rcx,%rsi)
jne 0x21930
addl $0x2, %eax
movl %eax, 0x4088f(%rip)     # 0x621b8
movl %edx, %edi
jmp 0x222f5
testl %eax, %eax
jns 0x222f5
pushq %rax
leaq 0x16240(%rip), %rdi     # 0x37b80
leaq 0x15f56(%rip), %rsi     # 0x3789d
leaq 0x1623c(%rip), %rcx     # 0x37b8a
movl $0x3b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: typaram
static Tok *
typaram(void)
{
	Tok *t;
	char buf[1024];

	t = NULL;
	if (!match('@'))
		return NULL;
	if (!identstr(buf, 1024))
		return NULL;
	t = mktok(Ttyparam);
	t->id = strdup(buf);
	return t;
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movslq 0x40851(%rip), %rax     # 0x621b8
cmpl 0x4083b(%rip), %eax     # 0x621a8
jge 0x219bc
movq 0x4082a(%rip), %rcx     # 0x621a0
cmpb $0x40, (%rcx,%rax)
jne 0x219bc
incl %eax
movl %eax, 0x40834(%rip)     # 0x621b8
movq %rsp, %rdi
callq 0x21e7b
testl %eax, %eax
je 0x219bc
movl $0x48, %edi
callq 0x2ce48
movq %rax, %rbx
movl $0x141, (%rax)          # imm = 0x141
movq 0x40806(%rip), %rax     # 0x621b0
movq %rax, 0x4(%rbx)
movq %rsp, %rdi
callq 0x4340
movq %rax, 0x10(%rbx)
jmp 0x219be
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: identstr
static int
identstr(char *buf, size_t sz)
{
	size_t i;
	char c;

	i = 0;
	for (c = peek(); i < sz && identchar(c); c = peek()) {
		next();
		buf[i++] = c;
	}
	buf[i] = '\0';
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x4032b(%rip), %r12     # 0x621b8
movslq 0x40314(%rip), %r14     # 0x621a8
movq 0x40305(%rip), %r15     # 0x621a0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl %r14d, %r12d
jge 0x21eaa
movsbl (%r15,%r12), %ebp
callq 0x4390
movq %rax, %rcx
movq %r12, %rdx
incq %rdx
leal 0x1(%r12), %esi
xorl %eax, %eax
movq (%rcx), %rdi
movslq %ebp, %r8
movzwl (%rdi,%r8,2), %edi
testb $0x8, %dil
jne 0x21eda
cmpl $0x5f, %ebp
je 0x21eda
cmpl $0x24, %ebp
jne 0x21f09
leal (%rsi,%rax), %edi
movl %edi, 0x402d5(%rip)     # 0x621b8
movb %bpl, (%rbx,%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %r14, %rdx
jge 0x21ef6
movsbl (%r15,%rdx), %ebp
incq %rax
incq %rdx
cmpq $0x400, %rax            # imm = 0x400
jne 0x21ebf
movl $0x400, %eax            # imm = 0x400
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: append
static void
append(char **buf, size_t *len, size_t *sz, int c)
{
	if (!*sz) {
		*sz = 16;
		*buf = malloc(*sz);
	}
	if (*len == *sz - 1) {
		*sz = *sz * 2;
		*buf = realloc(*buf, *sz);
	}

	buf[0][*len] = c;
	(*len)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %r13
testq %r13, %r13
je 0x22264
movq (%r15), %rax
jmp 0x2227f
movq $0x10, (%r12)
movl $0x10, %r13d
movl $0x10, %edi
callq 0x4280
movq %rax, (%r15)
movq (%r14), %rcx
leaq -0x1(%r13), %rdx
cmpq %rdx, %rcx
jne 0x222a3
addq %r13, %r13
movq %r13, (%r12)
movq %rax, %rdi
movq %r13, %rsi
callq 0x42a0
movq %rax, (%r15)
movq (%r14), %rcx
movb %bl, (%rax,%rcx)
incq (%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/tok.c
// Function: hexval
static int
hexval(char c)
{
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	else if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	else if (c >= '0' && c <= '9')
		return c - '0';
	lfatal(curloc, "passed non-hex value '%c' to where hex was expected", c);
	return -1;
}

// Assembly:
movl %edi, %edx
leal -0x61(%rdx), %ecx
movl $0xffffffa9, %eax       # imm = 0xFFFFFFA9
cmpb $0x6, %cl
jb 0x222dc
leal -0x41(%rdx), %ecx
movl $0xffffffc9, %eax       # imm = 0xFFFFFFC9
cmpb $0x6, %cl
jb 0x222dc
leal -0x30(%rdx), %ecx
movl $0xffffffd0, %eax       # imm = 0xFFFFFFD0
cmpb $0xa, %cl
jae 0x222df
addl %edx, %eax
retq
pushq %rax
movq 0x3fec9(%rip), %rdi     # 0x621b0
leaq 0x156ba(%rip), %rsi     # 0x379a8
xorl %eax, %eax
callq 0x139d2
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/type.c
// Function: isstacktype
int
isstacktype(Type *t)
{
	t = tybase(t);
	if (t->type == Tyunion)
		return !isenum(t);
	return stackness[t->type];
}

// Assembly:
pushq %rax
callq 0x227ac
movl (%rax), %ecx
cmpq $0x18, %rcx
jne 0x2279f
movq %rax, %rdi
callq 0x227e7
xorl $0x1, %eax
jmp 0x227aa
leaq 0x3e6aa(%rip), %rax     # 0x60e50
movsbl (%rcx,%rax), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/type.c
// Function: tybase
Type *
tybase(Type *t)
{
	assert(t != NULL);
	while (t->type == Tyname || t->type == Tygeneric)
		t = t->sub[0];
	return t;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x227d8
leaq 0x155d9(%rip), %rdi     # 0x37d92
leaq 0x1559c(%rip), %rsi     # 0x37d5c
leaq 0x155d5(%rip), %rcx     # 0x37d9c
movl $0x1eb, %edx            # imm = 0x1EB
callq 0x4180
movq 0x68(%rdi), %rax
movq (%rax), %rdi
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x1c, %eax
je 0x227d1
movq %rdi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/parse/type.c
// Function: isenum
int
isenum(Type *t)
{
	size_t i;
	char isenum;

	assert(t->type == Tyunion);

	/* t->isenum is lazily set:
	 * a value of 0 means that it was not computed,
	 * a value of 1 means that the type is an enum
	 * (i.e., it only has nullary constructors)
	 * a value of 2 means that the type is not an enum
	 */
	if (t->isenum == 0) {
		/* initialize it */
		isenum = 1;
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype) {
				isenum = 2;
				break;
			}
		t->isenum = isenum;
	}
	return t->isenum == 1;
}

// Assembly:
pushq %rax
cmpl $0x18, (%rdi)
jne 0x22832
movb 0x91(%rdi), %cl
testb %cl, %cl
jne 0x22828
movq 0x78(%rdi), %rax
movb $0x1, %cl
testq %rax, %rax
je 0x22822
movq 0x88(%rdi), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
cmpq $0x0, 0x28(%r8)
jne 0x22820
incq %rsi
cmpq %rsi, %rax
jne 0x2280b
jmp 0x22822
movb $0x2, %cl
movb %cl, 0x91(%rdi)
xorl %eax, %eax
cmpb $0x1, %cl
sete %al
popq %rcx
retq
leaq 0x13cc2(%rip), %rdi     # 0x364fb
leaq 0x1551c(%rip), %rsi     # 0x37d5c
leaq 0x1551c(%rip), %rcx     # 0x37d63
movl $0x3b, %edx
callq 0x4180