LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1e6c2
cmpl $0x9, 0x8(%rsi)
jne 0x1e6c2
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x1e6a7
cmpl $0x7, %eax
ja 0x1e6a7
movl %eax, %eax
leaq 0x18812(%rip), %rcx     # 0x36e6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x30(%rdi), %eax
cmpl 0x30(%rsi), %eax
jmp 0x1e6ba
movq 0x30(%rdi), %rax
cmpq 0x30(%rsi), %rax
jmp 0x1e6ba
movsd 0x30(%rsi), %xmm0
cmpeqsd 0x30(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1e6bd
movb $0x1, %al
jmp 0x1e6bd
movq 0x30(%rdi), %rdx
cmpq 0x30(%rsi), %rdx
jne 0x1e6a7
movq 0x38(%rdi), %rdi
movq 0x38(%rsi), %rsi
callq 0x4290
jmp 0x1e6b8
xorl %eax, %eax
jmp 0x1e6bd
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
callq 0x4230
testl %eax, %eax
sete %al
movzbl %al, %eax
popq %rcx
retq
leaq 0x188fe(%rip), %rdi     # 0x36fc7
leaq 0x1882c(%rip), %rsi     # 0x36efc
leaq 0x18913(%rip), %rcx     # 0x36fea
movl $0x204, %edx            # imm = 0x204
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1e74b
cmpl $0xa, 0x8(%rdi)
jne 0x1e753
movq 0x20(%rdi), %rax
retq
leaq 0x136e8(%rip), %rax     # 0x31e3a
retq
pushq %rax
leaq 0x18907(%rip), %rdi     # 0x37062
leaq 0x1879a(%rip), %rsi     # 0x36efc
leaq 0x1890d(%rip), %rcx     # 0x37076
movl $0x240, %edx            # imm = 0x240
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7cc
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x136b1(%rip), %rsi     # 0x31e3a
movq %rsi, %rdi
testq %r14, %r14
je 0x1e79c
cmpl $0xa, 0x8(%r14)
jne 0x1e7dd
movq 0x20(%r14), %rdi
testq %rbx, %rbx
je 0x1e7ab
cmpl $0xa, 0x8(%rbx)
jne 0x1e7dd
movq 0x20(%rbx), %rsi
callq 0x2dfda
testl %eax, %eax
je 0x1e7d3
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x2dfda
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x1e7d5
movl $0x1, %eax
jmp 0x1e7d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1887e(%rip), %rdi     # 0x37062
leaq 0x18711(%rip), %rsi     # 0x36efc
leaq 0x18884(%rip), %rcx     # 0x37076
movl $0x240, %edx            # imm = 0x240
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1e822
cmpl $0x35, 0x18(%rdi)
jne 0x1e841
movq 0x50(%rdi), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x1e860
cmpl $0x6, 0x18(%rax)
jne 0x1e87f
movq 0x30(%rax), %rax
popq %rcx
retq
leaq 0x1251f(%rip), %rdi     # 0x30d48
leaq 0x186cc(%rip), %rsi     # 0x36efc
leaq 0x18819(%rip), %rcx     # 0x37050
movl $0x237, %edx            # imm = 0x237
callq 0x4180
leaq 0x18844(%rip), %rdi     # 0x3708c
leaq 0x186ad(%rip), %rsi     # 0x36efc
leaq 0x18848(%rip), %rcx     # 0x3709e
movl $0x247, %edx            # imm = 0x247
callq 0x4180
leaq 0x1884c(%rip), %rdi     # 0x370b3
leaq 0x1868e(%rip), %rsi     # 0x36efc
leaq 0x18829(%rip), %rcx     # 0x3709e
movl $0x248, %edx            # imm = 0x248
callq 0x4180
leaq 0x1884b(%rip), %rdi     # 0x370d1
leaq 0x1866f(%rip), %rsi     # 0x36efc
leaq 0x1880a(%rip), %rcx     # 0x3709e
movl $0x249, %edx            # imm = 0x249
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1e8cb
cmpl $0x8, %ecx
jne 0x1e8d1
movl $0x38, %eax
cmpl $0x33, 0x18(%rdi)
jne 0x1e8ee
movq (%rdi,%rax), %rax
popq %rcx
retq
movq 0x25718(%rip), %rax     # 0x43ff0
movq (%rax), %rsi
callq 0x139c1
leaq 0x18834(%rip), %rdi     # 0x3711b
xorl %eax, %eax
callq 0x13a00
leaq 0x18801(%rip), %rdi     # 0x370f6
leaq 0x18600(%rip), %rsi     # 0x36efc
leaq 0x18805(%rip), %rcx     # 0x37108
movl $0x253, %edx            # imm = 0x253
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1e97e
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x1e982
decq %r12
jne 0x1e962
jmp 0x1e985
xorl %ebx, %ebx
jmp 0x1e985
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x1e9fb
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2db8b
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x1e9e6
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d5c5
// File: /workspace/github_c_makefile_star2_O1/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 0x1f4d8
movq %rdx, %r14
movq %rsi, %r12
leaq 0x400(%rsp), %r15
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rcx
leaq 0x17686(%rip), %rdx     # 0x36abd
movq %rsp, %rdi
movl $0x400, %ebp            # imm = 0x400
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x2e42e
leaq (%rsp,%rax), %r13
testq %r12, %r12
je 0x1f488
subq %rax, %rbp
leaq 0xfe17(%rip), %rdx      # 0x2f275
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2e42e
movq %rax, %rbp
addq %r13, %rbp
movq %r15, %rsi
subq %rbp, %rsi
movq %rbp, %rdi
movq %r12, %rdx
callq 0x24514
movq %rax, %r13
addq %rbp, %r13
movq %r15, %rsi
subq %r13, %rsi
leaq 0xfde0(%rip), %rdx      # 0x2f275
movq %r13, %rdi
xorl %eax, %eax
callq 0x2e42e
addq %rax, %r13
subq %r13, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24514
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x1d945
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x1f4dc
movq %r14, %rdi
callq 0x1df00
jmp 0x1f4dc
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_O1/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 0x1d832
movq %rax, %r13
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2d, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
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 0x2d3ff
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r14
leaq -0x6b(%rip), %r15       # 0x1fec4
leaq -0x63(%rip), %r12       # 0x1fed3
movq %r15, %rdi
movq %r12, %rsi
callq 0x2db1c
movq %rax, 0x18(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2db1c
movq %rax, 0x28(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2db1c
movq %rax, 0x30(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2db1c
movq %rax, 0x38(%r14)
testl %ebx, %ebx
je 0x1ffa4
leaq -0xb9(%rip), %rdi       # 0x1fec4
leaq -0xb1(%rip), %rsi       # 0x1fed3
callq 0x2db1c
movq %rax, 0x20(%r14)
leaq 0xdfa8(%rip), %rdi      # 0x2df3c
leaq 0xe03f(%rip), %rsi      # 0x2dfda
callq 0x2db1c
movq %rax, 0x40(%r14)
leaq 0x23(%rip), %rdi        # 0x1ffce
leaq 0x4c(%rip), %rsi        # 0x1fffe
callq 0x2db1c
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_O1/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 0x1e73b
movq %rax, %rdi
callq 0x2df3c
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x23e8e
imulq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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       # 0x200ed
leaq -0x36(%rip), %rsi       # 0x200f9
callq 0x2db1c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20183
movq 0x41c2b(%rip), %rax     # 0x61d90
cmpq $0x80, %rax
jae 0x20184
leaq 0x1(%rax), %rcx
movq %rcx, 0x41c18(%rip)     # 0x61d90
leaq 0x41c21(%rip), %rcx     # 0x61da0
movq %rdi, (%rcx,%rax,8)
retq
pushq %rax
leaq 0x17259(%rip), %rdi     # 0x373e5
leaq 0x171fc(%rip), %rsi     # 0x3738f
leaq 0x17264(%rip), %rcx     # 0x373fe
movl $0x9b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/stab.c
// Function: popenv
void
popenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff > 0);
	envstkoff--;
}

// Assembly:
testq %rdi, %rdi
je 0x201bf
movq 0x41be0(%rip), %rax     # 0x61d90
testq %rax, %rax
je 0x201c0
decq %rax
movq %rax, 0x41bd1(%rip)     # 0x61d90
retq
pushq %rax
leaq 0x1724c(%rip), %rdi     # 0x37414
leaq 0x171c0(%rip), %rsi     # 0x3738f
leaq 0x1724c(%rip), %rcx     # 0x37422
movl $0xa4, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x20224
leaq 0x4107e(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
callq 0x2dd9a
movq %rax, %r14
testq %rax, %rax
jne 0x20224
xorl %edi, %edi
callq 0x1ff11
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x20245
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x203c3
movq %rdi, %r14
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x8(%r14)
leaq 0x41005(%rip), %rcx     # 0x61278
movq 0xa0(%rcx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2dbc2
movq 0x18(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x202b6
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1df00
incq %r12
cmpq (%rsp), %r12
jb 0x202a1
movq %r15, %rdi
callq 0x4040
movq 0x28(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x202ef
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1df00
incq %r12
cmpq (%rsp), %r12
jb 0x202da
cmpq $0x0, (%rsp)
je 0x20331
xorl %r12d, %r12d
movq 0x28(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2dd9a
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x20328
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x1c, %ecx
jne 0x20328
movq 0x88(%rax), %rdi
movq %rbx, %rsi
callq 0x1df00
incq %r12
cmpq (%rsp), %r12
jb 0x202f9
movq %r15, %rdi
callq 0x4040
movq 0x30(%r14), %rdi
movq %rsp, %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r15
cmpq $0x0, (%r12)
je 0x20377
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2dd9a
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x1df00
incq %r12
cmpq (%rsp), %r12
jb 0x20355
movq %r15, %rdi
callq 0x4040
movq 0x38(%r14), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x2dedf
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x203af
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1df00
incq %r15
cmpq (%rsp), %r15
jb 0x2039a
movq %r14, %rdi
callq 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17211(%rip), %rdi     # 0x375db
movq %rbx, %rdx
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 0x203e7
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x203ea
movq (%rdi), %rdi
jmp 0x203d4
xorl %eax, %eax
retq
movq %rax, %rdi
jmp 0x2dd9a
// File: /workspace/github_c_makefile_star2_O1/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 0x2041b
movq %rdi, %r14
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x20426
movq (%r14), %r14
testq %r14, %r14
jne 0x2040a
movq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x2047d
xorl %r13d, %r13d
movq %r13, (%rsp)
movq %r13, (%rbx)
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x2dedf
movq %rax, %r15
cmpq %r13, (%r12)
je 0x20471
xorl %r13d, %r13d
movq %rsp, %r12
movq 0x20(%r14), %rdi
movq (%r15,%r13,8), %rsi
callq 0x2dd9a
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d3ff
incq %r13
cmpq 0x8(%rsp), %r13
jb 0x2044c
movq %r15, %rdi
callq 0x4040
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2dd9a
testq %rax, %rax
jne 0x204bc
movq (%r12), %r12
testq %r12, %r12
jne 0x2049c
xorl %r14d, %r14d
jmp 0x204ef
movq %rax, %r14
cmpq %rbx, %r12
je 0x204ef
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x204e7
cmpb $0x0, 0x71(%r14)
jne 0x204e7
cmpb $0x0, 0x73(%r14)
jne 0x204e7
movq 0x20(%r14), %rsi
movq %r14, %rdx
callq 0x2dbc2
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x204c4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20538
movq %rdi, %r15
cmpb $0x0, 0x10(%rdi)
je 0x20538
movq %rdx, %r14
movq %rsi, %rbx
movq 0x40(%r15), %rdi
callq 0x2decd
testl %eax, %eax
jne 0x20557
movq 0x40(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2dbc2
leaq 0x16ef8(%rip), %rdi     # 0x37437
leaq 0x16e49(%rip), %rsi     # 0x3738f
leaq 0x16efb(%rip), %rcx     # 0x37448
movl $0x106, %edx            # imm = 0x106
callq 0x4180
movl (%r14), %ecx
leaq 0x16f0b(%rip), %rsi     # 0x3746c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x205b1
movq %rdx, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%r14)
jne 0x2058e
movq (%r14), %r14
testq %r14, %r14
jne 0x2057d
jmp 0x205b1
movq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x2decd
testl %eax, %eax
je 0x205b1
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dd9a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2dd9a
testq %rax, %rax
jne 0x205fc
movq (%r15), %r15
testq %r15, %r15
jne 0x205e1
jmp 0x20600
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20693
leaq 0x40bf4(%rip), %rax     # 0x61278
movq 0xa0(%rax), %rdi
callq 0x2dd9a
movq %rax, %r14
xorl %r15d, %r15d
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x206b1
movq (%r14), %r14
testq %r14, %r14
jne 0x20696
jmp 0x206b5
movq 0x10(%rax), %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2dd9a
testq %rax, %rax
je 0x20a65
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x1e73b
leaq 0x16a69(%rip), %rdi     # 0x374dd
movq %rax, %rsi
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 0x20ae6
movl 0x10(%rbx), %ecx
cmpl $0x1, %ecx
jne 0x20a95
cmpl $0x1, 0x10(%rsi)
jne 0x20abe
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x20ae4
cmpl $0x1, 0x10(%rsi)
jne 0x20ae4
cmpq $0x0, 0x68(%rsi)
jne 0x20ae4
movq 0x68(%rbx), %rcx
testq %rcx, %rcx
je 0x20ae4
movq %rcx, 0x68(%rsi)
movq %rbx, %rax
movq %rsi, %rbx
jmp 0x20ad7
xorl %eax, %eax
cmpq $0x0, 0x68(%rbx)
jne 0x20ae4
movq 0x68(%rsi), %rcx
testq %rcx, %rcx
je 0x20ae4
movq %rcx, 0x68(%rbx)
movq %rsi, %rax
movq 0x70(%rax), %rax
movq %rax, 0x70(%rbx)
movl $0x1, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x23e44
movq 0x8(%rbx), %rdi
leaq 0x169f9(%rip), %rsi     # 0x374f2
movq %rax, %rdx
xorl %eax, %eax
callq 0x13b8e
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
callq 0x201e0
movq %rax, %r15
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x1df00
movq 0x8(%r15), %rsi
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x20b4b
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x20b4b
callq 0x1df00
xorl %r12d, %r12d
movq %r15, %r13
movq 0x28(%r13), %rdi
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x20b6d
movq (%r13), %r13
testq %r13, %r13
jne 0x20b51
jmp 0x20b71
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x20b8f
movq %r12, %rdi
movq %r14, %rsi
callq 0x20a7e
testl %eax, %eax
je 0x20c04
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
testq %r14, %r14
je 0x20bd4
movq %r15, %r12
movq 0x28(%r12), %rdi
movq %rbx, %rsi
callq 0x2decd
testl %eax, %eax
jne 0x20bb5
movq (%r12), %r12
testq %r12, %r12
jne 0x20b97
testl %eax, %eax
je 0x20bd4
movl $0x1, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20a41
movl $0x18, %edi
callq 0x2d379
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0x28(%r15), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dbc2
movq %r12, %rdi
callq 0x23e44
movq %rax, %r14
movq 0x8(%r12), %rdi
callq 0x1d56c
movq %rax, %r15
movq 0x8(%r12), %rdi
callq 0x1d580
leaq 0x168de(%rip), %rsi     # 0x3750b
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x2dd9a
testq %rax, %rax
jne 0x20c75
movq (%r13), %r13
testq %r13, %r13
jne 0x20c56
xorl %r15d, %r15d
jmp 0x20c78
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %r15, %r15
jne 0x20ca3
movq 0x8(%r14), %rsi
callq 0x1df00
movq 0x38(%r14), %rdi
movq 0x18(%rbx), %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dbc2
callq 0x1e73b
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1d56c
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1d580
movq (%r15), %rdi
leaq 0x16865(%rip), %rsi     # 0x3752d
movq %r14, %rdx
movq %r12, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x13b8e
// File: /workspace/github_c_makefile_star2_O1/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 0x201e0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20669
testq %rax, %rax
je 0x20d12
movq %rax, %r15
cmpb $0x0, 0x49(%rax)
je 0x20d3a
cmpb $0x0, 0x49(%r14)
setne %al
jmp 0x20d3c
xorl %r13d, %r13d
movq %r12, %r15
movq 0x28(%r15), %rdi
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x20dc7
movq (%r15), %r15
testq %r15, %r15
jne 0x20d18
jmp 0x20dcb
xorl %eax, %eax
movb 0x48(%r15), %cl
testb %cl, %cl
je 0x20d4f
cmpb $0x0, 0x48(%r14)
je 0x20e12
testb %cl, %cl
jne 0x20d6a
cmpb $0x0, 0x48(%r14)
je 0x20d6a
movl $0xa, %ecx
movq %r14, %rdi
movq %r15, %rsi
jmp 0x20e1d
cmpb $0x0, 0x4a(%r14)
jne 0x20e20
cmpb $0x0, 0x4a(%r15)
jne 0x20e20
cmpl $0x2, 0xc(%r14)
je 0x20d92
cmpl $0x2, 0xc(%r15)
jne 0x20e20
movq %rbx, %rdi
callq 0x1e73b
movq %rax, %r14
movq 0x4(%r15), %rdi
callq 0x1d56c
movq %rax, %r12
movq 0x4(%r15), %rdi
callq 0x1d580
leaq 0x16791(%rip), %rsi     # 0x3754a
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
jmp 0x20e62
movq 0x10(%rax), %r13
testq %r13, %r13
jne 0x20e32
movl $0x18, %edi
callq 0x2d379
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 0x1df00
movq 0x30(%r12), %rdi
movq 0x8(%r15), %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2dbc2
movl $0xa, %ecx
movq %r15, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movb %al, 0x49(%r14)
movb %al, 0x49(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1e73b
movq %rax, %r14
movq 0x8(%r13), %rdi
callq 0x1d56c
movq %rax, %r15
movq 0x8(%r13), %rdi
callq 0x1d580
leaq 0x16713(%rip), %rsi     # 0x3756c
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x201e0
movq %rax, %r14
movq %rax, %r15
movq 0x48(%r15), %rdi
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x20ea1
movq (%r15), %r15
testq %r15, %r15
jne 0x20e86
xorl %eax, %eax
testq %rax, %rax
je 0x20ee7
cmpb $0x0, 0x5d(%rax)
je 0x20eb2
cmpb $0x0, 0x5d(%rbx)
jne 0x20f0e
movl 0x58(%rax), %ecx
movl 0x58(%rbx), %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
movl %edx, 0x58(%rax)
movl %edx, 0x58(%rbx)
movb 0x5c(%rax), %cl
testb %cl, %cl
je 0x20ed0
cmpb $0x0, 0x5c(%rbx)
je 0x20f00
testb %cl, %cl
jne 0x20f35
cmpb $0x0, 0x5c(%rbx)
je 0x20f35
movl $0x10, %ecx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x20f0b
leaq 0x4038a(%rip), %rsi     # 0x61278
leaq 0x70(%rsi), %rdi
addq $0x78, %rsi
movq %rbx, %rdx
callq 0x2d3ff
jmp 0x20f0e
movl $0x10, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x1df00
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2dbc2
movq 0x18(%rbx), %rdi
callq 0x1e73b
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x23e44
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1d56c
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1d580
leaq 0x16629(%rip), %rsi     # 0x37590
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x402bc(%rip), %r14     # 0x61278
movq 0xa0(%r14), %rdi
callq 0x2dd9a
testq %rax, %rax
jne 0x20fe7
movq 0xa0(%r14), %rdi
movq 0x8(%rbx), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dbc2
movq 0x8(%rbx), %rdx
leaq 0x165cc(%rip), %rsi     # 0x375be
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x13b8e
// File: /workspace/github_c_makefile_star2_O1/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 0x2103c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d63c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2103d
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2d664
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x212bd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40ae6(%rip), %rax     # 0x61d90
testq %rax, %rax
je 0x212c0
leaq 0x40aea(%rip), %rcx     # 0x61da0
movq -0x8(%rcx,%rax,8), %r14
jmp 0x212d9
xorl %eax, %eax
retq
xorl %r14d, %r14d
jmp 0x212d9
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
jne 0x212e0
movq (%r14), %r14
testq %r14, %r14
jne 0x212c5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21404
movl %eax, %ebp
movl $0x1000, %edi           # imm = 0x1000
callq 0x4280
movq %rax, 0x40e8c(%rip)     # 0x621a0
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %rax, %rsi
callq 0x4200
testl %eax, %eax
js 0x2136d
xorl %ecx, %ecx
testl %eax, %eax
je 0x21382
movq 0x40e6c(%rip), %rdi     # 0x621a0
testq %rdi, %rdi
je 0x213f3
leal (%rax,%rcx), %r14d
leal (%rax,%rcx), %esi
addl $0x1000, %esi           # imm = 0x1000
callq 0x2d3d6
movq %rax, 0x40e4a(%rip)     # 0x621a0
leaq (%r14,%rax), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x4200
movl %r14d, %ecx
testl %eax, %eax
jns 0x21329
leaq 0x16480(%rip), %rdx     # 0x377f4
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x13aa3
movl %ecx, 0x40e20(%rip)     # 0x621a8
movq $0x1, 0x40e1d(%rip) # 0x621b0
movl %ebp, %edi
callq 0x41e0
movl 0x40e08(%rip), %eax     # 0x621a8
cmpl $0x3, %eax
jl 0x213df
movq 0x40df4(%rip), %rdx     # 0x621a0
cmpb $0x23, (%rdx)
jne 0x213df
cmpb $0x21, 0x1(%rdx)
jne 0x213df
xorl %ecx, %ecx
cmpb $0xa, (%rdx,%rcx)
je 0x213cb
incq %rcx
cmpq %rcx, %rax
jne 0x213b9
movl %eax, %ecx
jmp 0x213d9
movl %ecx, 0x40de7(%rip)     # 0x621b8
incl 0x40dd9(%rip)           # 0x621b0
incl %ecx
movl %ecx, 0x40dd9(%rip)     # 0x621b8
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x40dd2(%rip)     # 0x621c0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x16410(%rip), %rdi     # 0x3780a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x13a00
movq %rbx, %rdi
callq 0x47f7
// File: /workspace/github_c_makefile_star2_O1/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 0x22499(%rip), %rbx     # 0x43ff0
movq (%rbx), %rdi
movq 0x4065f(%rip), %rdx     # 0x621c0
movl 0x40649(%rip), %ecx     # 0x621b0
leaq 0x15cb5(%rip), %rsi     # 0x37823
xorl %eax, %eax
callq 0x4240
movq 0x4064c(%rip), %rax     # 0x621c8
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x21b96
movq (%rbx), %rdi
leaq 0x15c9e(%rip), %rsi     # 0x3782d
xorl %eax, %eax
callq 0x4240
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x41f0
movl $0x1, %edi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x3fefd(%rip), %rax     # 0x621b8
movslq 0x3fee6(%rip), %r14     # 0x621a8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl %r14d, %eax
jge 0x222d7
movq 0x3fecd(%rip), %rcx     # 0x621a0
movsbl (%rcx,%rax), %ebp
movslq 0x3feda(%rip), %r15     # 0x621b8
callq 0x4390
movq %rax, %rcx
movq 0x3feb3(%rip), %rdx     # 0x621a0
movq %r15, %rsi
incq %rsi
leal 0x1(%r15), %edi
xorl %eax, %eax
movq (%rcx), %r8
movslq %ebp, %r9
movzwl (%r8,%r9,2), %r8d
testb $0x8, %r8b
jne 0x22314
cmpl $0x5f, %ebp
je 0x22314
cmpl $0x24, %ebp
jne 0x22344
leal (%rdi,%rax), %r8d
movl %r8d, 0x3fe99(%rip)     # 0x621b8
movb %bpl, (%rbx,%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %r14, %rsi
jge 0x22331
movsbl (%rdx,%rsi), %ebp
incq %rax
incq %rsi
cmpq $0x400, %rax            # imm = 0x400
jne 0x222f9
movl $0x400, %eax            # imm = 0x400
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rdx)
jne 0x226e1
movq $0x10, (%r12)
movl $0x10, %edi
callq 0x4280
movq %rax, (%r15)
movq (%r12), %rsi
leaq -0x1(%rsi), %rax
cmpq %rax, (%r14)
jne 0x22700
addq %rsi, %rsi
movq %rsi, (%r12)
movq (%r15), %rdi
callq 0x42a0
movq %rax, (%r15)
movq (%r15), %rax
movq (%r14), %rcx
movb %bl, (%rax,%rcx)
incq (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22741
leal -0x41(%rdx), %ecx
movl $0xffffffc9, %eax       # imm = 0xFFFFFFC9
cmpb $0x6, %cl
jb 0x22741
leal -0x30(%rdx), %ecx
movl $0xffffffd0, %eax       # imm = 0xFFFFFFD0
cmpb $0xa, %cl
jae 0x22744
addl %edx, %eax
retq
pushq %rax
movq 0x3fa64(%rip), %rdi     # 0x621b0
leaq 0x15265(%rip), %rsi     # 0x379b8
xorl %eax, %eax
callq 0x13b8e
// File: /workspace/github_c_makefile_star2_O1/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 0x22c44
movl (%rax), %ecx
cmpq $0x18, %rcx
jne 0x22c37
movq %rax, %rdi
callq 0x22c7f
xorl $0x1, %eax
jmp 0x22c42
leaq 0x3e212(%rip), %rax     # 0x60e50
movsbl (%rcx,%rax), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22c70
leaq 0x15171(%rip), %rdi     # 0x37dc2
leaq 0x15134(%rip), %rsi     # 0x37d8c
leaq 0x1516d(%rip), %rcx     # 0x37dcc
movl $0x1eb, %edx            # imm = 0x1EB
callq 0x4180
movq 0x68(%rdi), %rax
movq (%rax), %rdi
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x1c, %eax
je 0x22c69
movq %rdi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22ccd
cmpb $0x0, 0x91(%rdi)
jne 0x22cbf
movq 0x78(%rdi), %rcx
movb $0x1, %al
testq %rcx, %rcx
je 0x22cb9
movq 0x88(%rdi), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
cmpq $0x0, 0x28(%r8)
jne 0x22cb7
incq %rsi
cmpq %rsi, %rcx
jne 0x22ca2
jmp 0x22cb9
movb $0x2, %al
movb %al, 0x91(%rdi)
xorl %eax, %eax
cmpb $0x1, 0x91(%rdi)
sete %al
popq %rcx
retq
leaq 0x13817(%rip), %rdi     # 0x364eb
leaq 0x150b1(%rip), %rsi     # 0x37d8c
leaq 0x150b1(%rip), %rcx     # 0x37d93
movl $0x3b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/type.c
// Function: tydedup
Type *
tydedup(Type *ty)
{
	Type *had;

	had = htget(tydeduptab, ty);
	if (!had) {
		htput(tydeduptab, ty, ty);
		return ty;
	}
	/* if one is emitted, both are */
	ty->isemitted = ty->isemitted || had->isemitted;
	return had;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x3f4e9(%rip), %rdi     # 0x621e0
movq %rbx, %rsi
callq 0x2dd9a
testq %rax, %rax
je 0x22d21
movb $0x1, %cl
cmpb $0x0, 0x96(%rbx)
jne 0x22d19
cmpb $0x0, 0x96(%rax)
setne %cl
movb %cl, 0x96(%rbx)
jmp 0x22d36
movq 0x3f4b8(%rip), %rdi     # 0x621e0
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x2dbc2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/type.c
// Function: mktype
Type *
mktype(Srcloc loc, Ty ty)
{
	Type *t;

	/* the first 'n' types will be identity mapped: tytab[Tyint], eg,
	 * will map to an instantitaion of Tyint.
	 *
	 * This is accomplished at program startup by calling mktype() on
	 * each builtin type in order. As we do this, we put the type into
	 * the table as ususal, which gives us an identity mapping.
	 */
	if (ty <= Tyvalist && ty < ntypes)
		return types[ty];

	t = zalloc(sizeof(Type));
	t->type = ty;
	t->tid = ntypes++;
	t->loc = loc;
	tytab = xrealloc(tytab, ntypes * sizeof(Type *));
	tytab[t->tid] = NULL;
	types = xrealloc(types, ntypes * sizeof(Type *));
	types[t->tid] = t;
	if (ty <= Tyvalist) /* the last builtin atomic type */
		t->vis = Visbuiltin;

	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
cmpl $0x11, %esi
ja 0x22d62
movl %ebx, %eax
cmpq %rax, 0x3f498(%rip)     # 0x621e8
jbe 0x22d62
movq 0x3f47f(%rip), %rcx     # 0x621d8
movq (%rcx,%rax,8), %r14
jmp 0x22de5
movl $0xa0, %edi
callq 0x2d348
movq %rax, %r14
movl %ebx, (%rax)
movq 0x3f470(%rip), %rax     # 0x621e8
leaq 0x1(%rax), %rcx
movq %rcx, 0x3f465(%rip)     # 0x621e8
movl %eax, 0x4(%r14)
movq %r15, 0x8(%r14)
movq 0x3f43e(%rip), %rdi     # 0x621d0
leaq 0x8(,%rax,8), %rsi
callq 0x2d3d6
movq %rax, 0x3f42a(%rip)     # 0x621d0
movl 0x4(%r14), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0x3f41f(%rip), %rdi     # 0x621d8
movq 0x3f428(%rip), %rsi     # 0x621e8
shlq $0x3, %rsi
callq 0x2d3d6
movq %rax, 0x3f408(%rip)     # 0x621d8
movl 0x4(%r14), %ecx
movq %r14, (%rax,%rcx,8)
cmpl $0x11, %ebx
ja 0x22de5
movl $0x3, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/type.c
// Function: tydup
Type *
tydup(Type *t)
{
	Type *r;

	r = mktype(t->loc, t->type);
	r->resolved = 0;	/* re-resolving doesn't hurt */
	r->fixed = 0;		/* re-resolving doesn't hurt */

	r->arg = memdup(t->arg, t->narg * sizeof(Type *));
	r->narg = t->narg;
	r->inst = memdup(t->arg, t->narg * sizeof(Type *));
	r->ninst = t->ninst;

	r->sub = memdup(t->sub, t->nsub * sizeof(Type *));
	r->nsub = t->nsub;
	r->nmemb = t->nmemb;
	switch (t->type) {
	case Tyname:	r->name = t->name;	break;
	case Tyunres:	r->name = t->name;	break;
	case Tyarray:	r->asize = t->asize;	break;
	case Typaram:	r->pname = strdup(t->pname);	break;
	case Tystruct:	r->sdecls = memdup(t->sdecls, t->nmemb * sizeof(Node *));	break;
	case Tyunion:	r->udecls = memdup(t->udecls, t->nmemb * sizeof(Node *));	break;
	default: break;
	}
	return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %esi
movq 0x8(%rdi), %rdi
callq 0x22d38
movq %rax, %rbx
movw $0x0, 0x97(%rax)
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
shlq $0x3, %rsi
callq 0x2d60b
movq %rax, 0x40(%rbx)
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
shlq $0x3, %rsi
callq 0x2d60b
movq %rax, 0x50(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
shlq $0x3, %rsi
callq 0x2d60b
movq %rax, 0x68(%rbx)
movq 0x70(%r14), %rax
movq %rax, 0x70(%rbx)
movq 0x78(%r14), %rax
movq %rax, 0x78(%rbx)
movl (%r14), %eax
addl $-0x15, %eax
cmpl $0x7, %eax
ja 0x22eb8
leaq 0x14d63(%rip), %rcx     # 0x37be0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%r14), %rax
jmp 0x22eb1
movq 0x78(%r14), %rsi
movq 0x88(%r14), %rdi
shlq $0x3, %rsi
callq 0x2d60b
jmp 0x22eb1
movq 0x88(%r14), %rdi
callq 0x4340
movq %rax, 0x88(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/parse/type.c
// Function: mktrait
Trait *
mktrait(Srcloc loc, Node *name, Type *param,
	Type **aux, size_t naux,
	Node **proto, size_t nproto,
	int isproto)
{
	Trait *t;
	size_t i;

	t = zalloc(sizeof(Trait));
	t->uid = ntraittab++;
	t->loc = loc;
	if (t->uid < Ntraits)
		t->vis = Visbuiltin;
	t->vis = Visintern;
	t->name = name;
	t->param = param;
	t->proto = proto;
	t->nproto = nproto;
	t->aux = aux;
	t->env = mkenv();
	t->naux = naux;
	t->isproto = isproto;

	bindtype(t->env, param);
	for (i = 0; i < naux; i++)
		bindtype(t->env, aux[i]);

	for (i = 0; i < nproto; i++)
		if (proto[i]->decl.env)
			proto[i]->decl.env->super = t->env;


	traittab = xrealloc(traittab, ntraittab * sizeof(Trait *));
	traittab[t->uid] = t;
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbp
movq 0x50(%rsp), %r13
movl $0x50, %edi
callq 0x2d348
movq %rax, %rbx
movq 0x3f2f0(%rip), %rax     # 0x621f0
leaq 0x1(%rax), %rcx
movq %rcx, 0x3f2e5(%rip)     # 0x621f0
movl %eax, (%rbx)
movq %rbp, 0x4(%rbx)
cmpl $0x7, %eax
jg 0x22f1d
movl $0x3, 0xc(%rbx)
movl $0x0, 0xc(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x10(%rsp), %rbp
movq %rbp, 0x18(%rbx)
movq %r14, 0x30(%rbx)
movq %r13, 0x38(%rbx)
movq %r12, 0x20(%rbx)
callq 0x2010c
movq %rax, 0x40(%rbx)
movq %r15, 0x28(%rbx)
movl 0x58(%rsp), %ecx
movb %cl, 0x48(%rbx)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20ffe
testq %r15, %r15
je 0x22f7d
xorl %ebp, %ebp
movq 0x40(%rbx), %rdi
movq (%r12,%rbp,8), %rsi
callq 0x20ffe
incq %rbp
cmpq %rbp, %r15
jne 0x22f68
testq %r13, %r13
je 0x22fa0
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x22f98
movq 0x40(%rbx), %rdx
movq %rdx, (%rcx)
incq %rax
cmpq %rax, %r13
jne 0x22f84
movq 0x3f251(%rip), %rdi     # 0x621f8
movq 0x3f242(%rip), %rsi     # 0x621f0
shlq $0x3, %rsi
callq 0x2d3d6
movq %rax, 0x3f23a(%rip)     # 0x621f8
movslq (%rbx), %rcx
movq %rbx, (%rax,%rcx,8)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq