LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1be9a
pushq $0x35
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1fdc2
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bf0d
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rax
retq
pushq %rax
leaq 0x17028(%rip), %rdi     # 0x32f3d
leaq 0x16fc0(%rip), %rsi     # 0x32edc
leaq 0x1702b(%rip), %rcx     # 0x32f4e
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 0x1c07e
cmpl $0x9, 0x8(%rsi)
jne 0x1c07e
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x1c063
cmpl $0x7, %eax
ja 0x1c063
movl %eax, %eax
leaq 0x16e36(%rip), %rcx     # 0x32e4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x30(%rdi), %eax
cmpl 0x30(%rsi), %eax
jmp 0x1c076
movq 0x30(%rdi), %rax
cmpq 0x30(%rsi), %rax
jmp 0x1c076
movsd 0x30(%rsi), %xmm0
cmpeqsd 0x30(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1c079
movb $0x1, %al
jmp 0x1c079
movq 0x30(%rdi), %rdx
cmpq 0x30(%rsi), %rdx
jne 0x1c063
movq 0x38(%rdi), %rdi
movq 0x38(%rsi), %rsi
callq 0x4290
jmp 0x1c074
xorl %eax, %eax
jmp 0x1c079
movq 0x30(%rdi), %rdi
movq 0x30(%rsi), %rsi
callq 0x4230
testl %eax, %eax
sete %al
movzbl %al, %eax
popq %rcx
retq
leaq 0x16f22(%rip), %rdi     # 0x32fa7
leaq 0x16e50(%rip), %rsi     # 0x32edc
leaq 0x16f37(%rip), %rcx     # 0x32fca
movl $0x204, %edx            # imm = 0x204
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 0x1c0d8
cmpl $0xa, 0x8(%rdi)
jne 0x1c0e0
movq 0x20(%rdi), %rax
retq
leaq 0x11d6b(%rip), %rax     # 0x2de4a
retq
pushq %rax
leaq 0x16f5a(%rip), %rdi     # 0x33042
leaq 0x16ded(%rip), %rsi     # 0x32edc
leaq 0x16f60(%rip), %rcx     # 0x33056
movl $0x240, %edx            # imm = 0x240
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x1b5e6
cmpl $0x35, %eax
jne 0x1c17a
movq 0x50(%rbx), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x1c199
cmpl $0x6, 0x18(%rax)
jne 0x1c1b8
movq 0x30(%rax), %rax
popq %rbx
retq
leaq 0x16eeb(%rip), %rdi     # 0x3306c
leaq 0x16d54(%rip), %rsi     # 0x32edc
leaq 0x16eef(%rip), %rcx     # 0x3307e
movl $0x247, %edx            # imm = 0x247
callq 0x4180
leaq 0x16ef3(%rip), %rdi     # 0x33093
leaq 0x16d35(%rip), %rsi     # 0x32edc
leaq 0x16ed0(%rip), %rcx     # 0x3307e
movl $0x248, %edx            # imm = 0x248
callq 0x4180
leaq 0x16ef2(%rip), %rdi     # 0x330b1
leaq 0x16d16(%rip), %rsi     # 0x32edc
leaq 0x16eb1(%rip), %rcx     # 0x3307e
movl $0x249, %edx            # imm = 0x249
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0xb, %eax
je 0x1c208
cmpl $0x8, %eax
jne 0x1c211
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x33, %eax
jne 0x1c231
pushq $0x38
jmp 0x1c20a
pushq $0x18
popq %rax
movq (%rbx,%rax), %rax
popq %rbx
retq
movq 0x24dd8(%rip), %rax     # 0x40ff0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1201b
leaq 0x16ed1(%rip), %rdi     # 0x330fb
xorl %eax, %eax
callq 0x1205c
leaq 0x16e9e(%rip), %rdi     # 0x330d6
leaq 0x16c9d(%rip), %rsi     # 0x32edc
leaq 0x16ea2(%rip), %rcx     # 0x330e8
movl $0x253, %edx            # imm = 0x253
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
xorl %ebx, %ebx
subq $0x1, %r12
jb 0x1c2be
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x2a3e8
testq %rax, %rax
je 0x1c2a1
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
cmpq (%rbx), %r15
jae 0x1c33e
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x2a1f3
incq %r15
jmp 0x1c328
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x29cc7
// File: /workspace/github_c_makefile_star2_O2/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 0x1cd50
movq %rdx, %r14
movq %rsi, %r12
leaq 0x400(%rsp), %r15
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rcx
leaq 0x15dee(%rip), %rdx     # 0x32a9d
movq %rsp, %rdi
movl $0x400, %ebp            # imm = 0x400
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x2a9bf
leaq (%rsp,%rax), %r13
testq %r12, %r12
je 0x1cd00
subq %rax, %rbp
leaq 0xe59f(%rip), %rdx      # 0x2b275
movq %r13, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2a9bf
movq %rax, %rbp
addq %r13, %rbp
movq %r15, %rsi
subq %rbp, %rsi
movq %rbp, %rdi
movq %r12, %rdx
callq 0x21651
movq %rax, %r13
addq %rbp, %r13
movq %r15, %rsi
subq %r13, %rsi
leaq 0xe568(%rip), %rdx      # 0x2b275
movq %r13, %rdi
xorl %eax, %eax
callq 0x2a9bf
addq %rax, %r13
subq %r13, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21651
movq (%rbx), %rdi
movq %rsp, %rsi
callq 0x1b7fd
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x1cd54
movq %r14, %rdi
callq 0x1bb2f
jmp 0x1cd54
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_O2/oridb[P]mc/parse/specialize.c
// Function: fillsubst
static void
fillsubst(Tysubst *tsmap, Type *to, Type *from)
{
	size_t i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
cmpl $0x1a, (%rdx)
jne 0x1d1c3
leaq 0x4113f(%rip), %rax     # 0x5e1e0
cmpb $0x0, 0x53(%rax)
je 0x1d0ce
movq %rbx, %rdi
callq 0x21009
movq %rax, %r12
movq %r14, %rdi
callq 0x21009
leaq 0x1620f(%rip), %rdi     # 0x332d0
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4140
movq (%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c27c
xorl %r12d, %r12d
cmpq 0x20(%rbx), %r12
jae 0x1d230
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq 0x8(%rax), %rbp
jae 0x1d1bb
xorl %r13d, %r13d
cmpq 0x20(%r14), %r13
jae 0x1d162
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rax
cmpq 0x8(%rax), %r15
jae 0x1d15d
movq 0x18(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movq (%rcx), %rcx
movq (%rcx,%rbp,8), %rdi
movq (%rax), %rax
movq (%rax,%r15,8), %rsi
callq 0x1c100
testl %eax, %eax
je 0x1d158
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x18(%rax), %rdx
movq (%rsp), %rdi
callq 0x1d07c
incq %r15
jmp 0x1d10a
incq %r13
jmp 0x1d101
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rax
movq (%rax,%rbp,8), %rdi
leaq 0x42080(%rip), %rax     # 0x5f1f8
movq (%rax), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x1c100
testl %eax, %eax
je 0x1d1b3
movl (%r14), %eax
andl $-0x2, %eax
cmpl $0x14, %eax
jne 0x1d1b3
movq 0x68(%r14), %rax
movq (%rax), %rsi
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x18(%rax), %rdx
movq (%rsp), %rdi
callq 0x1d07c
incq %rbp
jmp 0x1d0ec
incq %r12
jmp 0x1d0e0
movq 0x70(%r14), %rax
cmpq 0x70(%rbx), %rax
jne 0x1d23f
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x1d1f7
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rsi
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq (%rsp), %rdi
callq 0x1d07c
incq %r15
movq 0x70(%r14), %rax
jmp 0x1d1d0
cmpl $0x1c, (%r14)
jne 0x1d230
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x1d230
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x1d230
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rsi
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq (%rsp), %rdi
callq 0x1d07c
incq %r15
movq 0x48(%r14), %rax
jmp 0x1d209
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1609c(%rip), %rdi     # 0x332e2
leaq 0x15f78(%rip), %rsi     # 0x331c5
leaq 0x160a5(%rip), %rcx     # 0x332f9
movl $0xea, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x33
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r13
pushq $0x2d
popq %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
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 0x29b2d
// File: /workspace/github_c_makefile_star2_O2/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 0x29a78
movq %rax, %r14
leaq -0x69(%rip), %r15       # 0x1d6f0
leaq -0x61(%rip), %r12       # 0x1d6ff
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a188
movq %rax, 0x18(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a188
movq %rax, 0x28(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a188
movq %rax, 0x30(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a188
movq %rax, 0x38(%r14)
testl %ebx, %ebx
je 0x1d7ce
leaq -0xb7(%rip), %rdi       # 0x1d6f0
leaq -0xaf(%rip), %rsi       # 0x1d6ff
callq 0x2a188
movq %rax, 0x20(%r14)
leaq 0xcdc5(%rip), %rdi      # 0x2a583
leaq 0xce61(%rip), %rsi      # 0x2a626
callq 0x2a188
movq %rax, 0x40(%r14)
leaq 0x23(%rip), %rdi        # 0x1d7f8
leaq 0x44(%rip), %rsi        # 0x1d820
callq 0x2a188
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_O2/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
pushq $0x10
popq %rdi
callq 0x4280
movq %rax, %rbx
andq $0x0, (%rax)
leaq -0x36(%rip), %rdi       # 0x1d909
leaq -0x31(%rip), %rsi       # 0x1d915
callq 0x2a188
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d99a
movq 0x41414(%rip), %rax     # 0x5ed90
cmpq $0x80, %rax
jae 0x1d99b
leaq 0x1(%rax), %rcx
movq %rcx, 0x41401(%rip)     # 0x5ed90
leaq 0x4140a(%rip), %rcx     # 0x5eda0
movq %rdi, (%rcx,%rax,8)
retq
pushq %rax
leaq 0x15a22(%rip), %rdi     # 0x333c5
leaq 0x159c5(%rip), %rsi     # 0x3336f
leaq 0x15a2d(%rip), %rcx     # 0x333de
movl $0x9b, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/stab.c
// Function: popenv
void
popenv(Tyenv *env)
{
	if (!env)
		return;
	assert(envstkoff > 0);
	envstkoff--;
}

// Assembly:
testq %rdi, %rdi
je 0x1d9d6
movq 0x413c9(%rip), %rax     # 0x5ed90
testq %rax, %rax
je 0x1d9d7
decq %rax
movq %rax, 0x413ba(%rip)     # 0x5ed90
retq
pushq %rax
leaq 0x15a15(%rip), %rdi     # 0x333f4
leaq 0x15989(%rip), %rsi     # 0x3336f
leaq 0x15a15(%rip), %rcx     # 0x33402
movl $0xa4, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r14
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x1da2d
movq %rsi, %rbx
callq 0x1da38
movq %rax, %r14
testq %rax, %rax
jne 0x1da2d
xorl %edi, %edi
callq 0x1d73b
movq %rax, %r14
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x1da4e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1dbae
movq %rdi, %r14
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x8(%r14)
leaq 0x407fc(%rip), %rcx     # 0x5e278
movq 0xa0(%rcx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a22a
movq 0x18(%r14), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r15
xorl %r12d, %r12d
cmpq (%rsp), %r12
jae 0x1dab7
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1bb2f
incq %r12
jmp 0x1daa0
movq %r15, %rdi
callq 0x4040
movq 0x28(%r14), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r15
xorl %r12d, %r12d
movq (%rsp), %rax
cmpq %rax, %r12
jae 0x1daeb
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x1bb2f
incq %r12
jmp 0x1dad1
xorl %r12d, %r12d
cmpq %rax, %r12
jae 0x1db2b
movq 0x28(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2a3e8
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x1db22
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x1c, %ecx
jne 0x1db22
movq 0x88(%rax), %rdi
movq %rbx, %rsi
callq 0x1bb2f
incq %r12
movq (%rsp), %rax
jmp 0x1daee
movq %r15, %rdi
callq 0x4040
movq 0x30(%r14), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r15
xorl %r12d, %r12d
cmpq (%rsp), %r12
jae 0x1db69
movq 0x30(%r14), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2a3e8
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x1bb2f
incq %r12
jmp 0x1db45
movq %r15, %rdi
callq 0x4040
movq 0x38(%r14), %rdi
movq %rsp, %rsi
callq 0x2a529
movq %rax, %r14
xorl %r15d, %r15d
cmpq (%rsp), %r15
jae 0x1db9a
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1bb2f
incq %r15
jmp 0x1db83
movq %r14, %rdi
callq 0x4040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x15a06(%rip), %rdi     # 0x335bb
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 0x1dbd2
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x1dbd5
movq (%rdi), %rdi
jmp 0x1dbbf
xorl %eax, %eax
retq
movq %rax, %rdi
jmp 0x2a3e8
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
testq %r14, %r14
je 0x1dc03
movq 0x20(%r14), %rdi
testq %rdi, %rdi
jne 0x1dc0b
movq (%r14), %r14
jmp 0x1dbf0
andq $0x0, (%rbx)
xorl %eax, %eax
jmp 0x1dc59
movq %rsp, %r15
andq $0x0, (%r15)
andq $0x0, (%rbx)
leaq 0x8(%rsp), %rsi
callq 0x2a529
movq %rax, %r12
xorl %r13d, %r13d
cmpq 0x8(%rsp), %r13
jae 0x1dc4d
movq 0x20(%r14), %rdi
movq (%r12,%r13,8), %rsi
callq 0x2a3e8
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x29b2d
incq %r13
jmp 0x1dc26
movq %r12, %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_O2/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 0x2a3e8
movq %rax, %r14
testq %rax, %rax
jne 0x1dcbe
movq (%r12), %r12
testq %r12, %r12
jne 0x1dc78
jmp 0x1dcc3
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1dcbb
cmpb $0x0, 0x71(%r14)
jne 0x1dcbb
cmpb $0x0, 0x73(%r14)
jne 0x1dcbb
movq 0x20(%r14), %rsi
movq %r14, %rdx
callq 0x2a22a
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x1dc98
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1dd0c
movq %rdi, %r15
cmpb $0x0, 0x10(%rdi)
je 0x1dd0c
movq %rdx, %r14
movq %rsi, %rbx
movq 0x40(%r15), %rdi
callq 0x2a517
testl %eax, %eax
jne 0x1dd2b
movq 0x40(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a22a
leaq 0x15704(%rip), %rdi     # 0x33417
leaq 0x15655(%rip), %rsi     # 0x3336f
leaq 0x15707(%rip), %rcx     # 0x33428
movl $0x106, %edx            # imm = 0x106
callq 0x4180
movl (%r14), %ecx
leaq 0x15717(%rip), %rsi     # 0x3344c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x1dd80
cmpb $0x0, 0x10(%r14)
jne 0x1dd5d
movq (%r14), %r14
jmp 0x1dd4c
movq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x2a517
testl %eax, %eax
je 0x1dd80
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a3e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a3e8
testq %rax, %rax
jne 0x1ddcb
movq (%r15), %r15
testq %r15, %r15
jne 0x1ddb0
jmp 0x1ddcf
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
testq %rdi, %rdi
je 0x1de4f
callq 0x1da38
movq %rax, %r14
xorl %r15d, %r15d
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
testq %rax, %rax
jne 0x1de6d
movq (%r14), %r14
testq %r14, %r14
jne 0x1de52
jmp 0x1de71
movq 0x10(%rax), %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a3e8
testq %rax, %rax
je 0x1e20e
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x1c0c8
leaq 0x152a0(%rip), %rdi     # 0x334bd
movq %rax, %rsi
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 0x1e287
cmpl $0x1, 0x10(%rbx)
movl 0x10(%rsi), %ecx
jne 0x1e259
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x1e285
cmpq $0x0, 0x68(%rbx)
jne 0x1e285
movq 0x68(%rsi), %rcx
testq %rcx, %rcx
je 0x1e285
movq %rcx, 0x68(%rbx)
movq %rsi, %rax
jmp 0x1e27a
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x1e285
cmpq $0x0, 0x68(%rsi)
jne 0x1e285
movq 0x68(%rbx), %rcx
testq %rcx, %rcx
je 0x1e285
movq %rcx, 0x68(%rsi)
movq %rbx, %rax
movq %rsi, %rbx
movq 0x70(%rax), %rax
movq %rax, 0x70(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
movq %rbx, %rdi
callq 0x21009
movq 0x8(%rbx), %rdi
leaq 0x15238(%rip), %rsi     # 0x334d2
movq %rax, %rdx
xorl %eax, %eax
callq 0x121e4
// File: /workspace/github_c_makefile_star2_O2/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 0x1d9f7
movq %rax, %r15
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x1bb2f
movq 0x8(%r15), %rsi
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1e2eb
movq 0x88(%r14), %rdi
testq %rdi, %rdi
je 0x1e2eb
callq 0x1bb2f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1dda3
testq %rax, %rax
je 0x1e319
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x1e227
testl %eax, %eax
je 0x1e37e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %r14, %r14
je 0x1e34e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ddd8
testl %eax, %eax
je 0x1e34e
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 0x1e1ea
pushq $0x18
popq %rdi
callq 0x29aa7
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 0x2a22a
movq %r12, %rdi
callq 0x21009
movq %rax, %r14
movq 0x8(%r12), %rdi
callq 0x1b4f4
movq %rax, %r15
movq 0x8(%r12), %rdi
callq 0x1b508
leaq 0x15144(%rip), %rsi     # 0x334eb
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rsi), %rsi
callq 0x1de08
movq 0x18(%rbx), %rdi
testq %rax, %rax
jne 0x1e3fe
movq 0x8(%r15), %rsi
callq 0x1bb2f
movq 0x38(%r15), %rdi
movq 0x18(%rbx), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a22a
movq %rax, %r14
callq 0x1c0c8
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1b4f4
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1b508
movq (%r14), %rdi
leaq 0x150e7(%rip), %rsi     # 0x3350d
movq %r15, %rdx
movq %r12, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x121e4
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0x1d9f7
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1de33
testq %rax, %rax
je 0x1e46f
movq %rax, %r15
cmpb $0x0, 0x49(%rax)
je 0x1e4c5
cmpb $0x0, 0x49(%r14)
setne %al
jmp 0x1e4c7
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1dda3
testq %rax, %rax
jne 0x1e523
pushq $0x18
popq %rdi
callq 0x29aa7
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 0x1bb2f
movq 0x30(%r12), %rdi
movq 0x8(%r15), %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a22a
xorl %eax, %eax
cmpb $0x0, 0x48(%r15)
movb 0x48(%r14), %cl
je 0x1e4e1
testb %cl, %cl
jne 0x1e4f3
pushq $0xa
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
jmp 0x1e4ee
testb %cl, %cl
je 0x1e4f3
pushq $0xa
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x1e50f
cmpb $0x0, 0x4a(%r14)
jne 0x1e50f
cmpb $0x0, 0x4a(%r15)
jne 0x1e50f
cmpl $0x2, 0xc(%r14)
je 0x1e560
cmpl $0x2, 0xc(%r15)
je 0x1e560
movb %al, 0x49(%r14)
movb %al, 0x49(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rbx, %rdi
callq 0x1c0c8
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x1b4f4
movq %rax, %r12
movq 0x8(%r15), %rdi
callq 0x1b508
leaq 0x14fff(%rip), %rsi     # 0x3354c
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movl %eax, %r8d
xorl %eax, %eax
callq 0x120fd
movq %rbx, %rdi
callq 0x1c0c8
movq %rax, %r14
movq 0x4(%r15), %rdi
callq 0x1b4f4
movq %rax, %r12
movq 0x4(%r15), %rdi
callq 0x1b508
leaq 0x14fa3(%rip), %rsi     # 0x3352a
jmp 0x1e54d
// File: /workspace/github_c_makefile_star2_O2/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 0x1d9f7
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1e67d
testq %rax, %rax
je 0x1e5e5
cmpb $0x0, 0x5d(%rax)
je 0x1e5bc
cmpb $0x0, 0x5d(%rbx)
jne 0x1e60e
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 0x1e5fe
testb %cl, %cl
jne 0x1e635
pushq $0x10
popq %rcx
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x1e60b
leaq 0x3fc8c(%rip), %rsi     # 0x5e278
leaq 0x70(%rsi), %rdi
addq $0x78, %rsi
movq %rbx, %rdx
callq 0x29b2d
jmp 0x1e60e
testb %cl, %cl
je 0x1e635
pushq $0x10
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x1bb2f
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a22a
movq 0x18(%rbx), %rdi
callq 0x1c0c8
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x21009
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1b4f4
movq %rax, %r12
movq (%rbx), %rdi
callq 0x1b508
leaq 0x14f09(%rip), %rsi     # 0x33570
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1da38
testq %rax, %rax
jne 0x1e6d5
leaq 0x3fbb7(%rip), %rax     # 0x5e278
movq 0xa0(%rax), %rdi
movq 0x8(%rbx), %rsi
movq %rbx, %rdx
popq %rbx
jmp 0x2a22a
movq 0x8(%rbx), %rdx
leaq 0x14ebe(%rip), %rsi     # 0x3359e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x121e4
// File: /workspace/github_c_makefile_star2_O2/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 0x1e72a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29d3c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1e72b
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x29d60
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/stab.c
// Function: boundtype
Type*
boundtype(Type *t)
{
	Tyenv *e;
	Type *r;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1a, (%rdi)
jne 0x1e966
movq %rdi, %rbx
movq 0x40445(%rip), %rax     # 0x5ed90
testq %rax, %rax
je 0x1e961
leaq 0x40449(%rip), %rcx     # 0x5eda0
leaq (%rcx,%rax,8), %r14
addq $-0x8, %r14
jmp 0x1e96a
xorl %r14d, %r14d
jmp 0x1e96d
xorl %eax, %eax
jmp 0x1e983
movq (%r14), %r14
testq %r14, %r14
je 0x1e966
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2a3e8
testq %rax, %rax
je 0x1e96a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x42d0
cmpl $-0x1, %eax
je 0x1ea9c
movl %eax, %ebp
movl $0x1000, %edi           # imm = 0x1000
callq 0x4280
movq %rax, 0x407e2(%rip)     # 0x5f1a0
movl %r14d, %esi
addq %rax, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x4200
testl %eax, %eax
js 0x1ea76
je 0x1ea02
movq 0x407bf(%rip), %rdi     # 0x5f1a0
testq %rdi, %rdi
je 0x1ea8b
leal (%r14,%rax), %r15d
leal (%r14,%rax), %esi
addl $0x1000, %esi           # imm = 0x1000
callq 0x29b04
movl %r15d, %r14d
jmp 0x1e9b7
movl %r14d, 0x4079f(%rip)    # 0x5f1a8
movq $0x1, 0x4079c(%rip) # 0x5f1b0
movl %ebp, %edi
callq 0x41e0
movl 0x40787(%rip), %eax     # 0x5f1a8
cmpl $0x3, %eax
jl 0x1ea5c
movq 0x40773(%rip), %rdx     # 0x5f1a0
cmpb $0x23, (%rdx)
jne 0x1ea5c
cmpb $0x21, 0x1(%rdx)
jne 0x1ea5c
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1ea4a
cmpb $0xa, (%rdx,%rcx)
je 0x1ea4e
incq %rcx
jmp 0x1ea3a
movl %eax, %ecx
jmp 0x1ea56
incl 0x4075c(%rip)           # 0x5f1b0
incl %ecx
movl %ecx, 0x4075c(%rip)     # 0x5f1b8
movq %rbx, %rdi
callq 0x4340
movq %rax, 0x40755(%rip)     # 0x5f1c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14d57(%rip), %rdx     # 0x337d4
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x120fd
leaq 0x14d58(%rip), %rdi     # 0x337ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1205c
movq 0x2254d(%rip), %rax     # 0x40ff0
movq (%rax), %rdi
leaq 0x14d0f(%rip), %rsi     # 0x337bc
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4240
pushq $0x1
popq %rdi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O2/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 0x217f3(%rip), %rbx     # 0x40ff0
movq (%rbx), %rdi
movq 0x3f9b9(%rip), %rdx     # 0x5f1c0
movl 0x3f9a3(%rip), %ecx     # 0x5f1b0
leaq 0x13fef(%rip), %rsi     # 0x33803
xorl %eax, %eax
callq 0x4240
movq 0x3f9a6(%rip), %rax     # 0x5f1c8
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x1f83c
movq (%rbx), %rdi
leaq 0x13fd8(%rip), %rsi     # 0x3380d
xorl %eax, %eax
callq 0x4240
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x41f0
pushq $0x1
popq %rdi
callq 0x4320
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/tok.c
// Function: mktok
static Tok *
mktok(int tt)
{
	Tok *t;

	t = zalloc(sizeof(Tok));
	t->type = tt;
	t->loc = curloc;
	return t;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x48
popq %rdi
callq 0x29a78
movl %ebx, (%rax)
movq 0x3f94d(%rip), %rcx     # 0x5f1b0
movq %rcx, 0x4(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/tok.c
// Function: next
static int
next(void)
{
	int c;

	c = peek();
	fidx++;
	return c;
}

// Assembly:
movslq 0x3f948(%rip), %rcx     # 0x5f1b8
cmpl 0x3f932(%rip), %ecx     # 0x5f1a8
jge 0x1f885
movq 0x3f921(%rip), %rax     # 0x5f1a0
movsbl (%rax,%rcx), %eax
jmp 0x1f888
pushq $-0x1
popq %rax
incl %ecx
movl %ecx, 0x3f928(%rip)     # 0x5f1b8
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/parse/tok.c
// Function: match
static int
peekn(int n)
{
	if (fidx + n >= fbufsz)
		return End;
	else
		return fbuf[fidx + n];
}

// Assembly:
movslq 0x3f920(%rip), %rcx     # 0x5f1b8
xorl %eax, %eax
cmpl 0x3f908(%rip), %ecx     # 0x5f1a8
jge 0x1f8bc
movq 0x3f8f7(%rip), %rdx     # 0x5f1a0
cmpb %dil, (%rdx,%rcx)
jne 0x1f8bc
pushq %rax
callq 0x1f869
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3f8e7(%rip), %eax     # 0x5f1b8
movl 0x3f8d1(%rip), %ebp     # 0x5f1a8
xorl %r14d, %r14d
pushq $-0x1
popq %r15
movq 0x3f8bb(%rip), %r12     # 0x5f1a0
movl %r15d, %r13d
cmpl %ebp, %eax
jl 0x1f928
cmpq $0x400, %r14            # imm = 0x400
je 0x1f931
callq 0x4390
movq (%rax), %rax
movslq %r13d, %rcx
movzwl (%rax,%rcx,2), %eax
testb $0x8, %al
jne 0x1f914
cmpl $0x5f, %r13d
je 0x1f914
cmpl $0x24, %r13d
jne 0x1f931
callq 0x1f869
movb %r13b, (%rbx,%r14)
incq %r14
movl 0x3f892(%rip), %eax     # 0x5f1b8
jmp 0x1f8e5
cltq
movsbl (%r12,%rax), %r13d
jmp 0x1f8ec
movb $0x0, (%rbx,%r14)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fbf8
movq (%r15), %rax
jmp 0x1fc0f
movq $0x10, (%r12)
pushq $0x10
popq %r13
movq %r13, %rdi
callq 0x4280
movq %rax, (%r15)
movq (%r14), %rcx
leaq -0x1(%r13), %rdx
cmpq %rdx, %rcx
jne 0x1fc33
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_O2/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), %eax
cmpb $0x6, %al
jae 0x1fc50
pushq $-0x57
jmp 0x1fc64
leal -0x41(%rdx), %eax
cmpb $0x6, %al
jae 0x1fc5b
pushq $-0x37
jmp 0x1fc64
leal -0x30(%rdx), %eax
cmpb $0xa, %al
jae 0x1fc68
pushq $-0x30
popq %rax
addl %edx, %eax
retq
pushq %rax
movq 0x3f540(%rip), %rdi     # 0x5f1b0
leaq 0x13d21(%rip), %rsi     # 0x33998
xorl %eax, %eax
callq 0x121e4
// File: /workspace/github_c_makefile_star2_O2/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 0x1fcd8
movl (%rax), %ecx
cmpq $0x18, %rcx
jne 0x1fccb
movq %rax, %rdi
callq 0x1fd13
xorl $0x1, %eax
jmp 0x1fcd6
leaq 0x3e17e(%rip), %rax     # 0x5de50
movsbl (%rcx,%rax), %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fd04
leaq 0x140bd(%rip), %rdi     # 0x33da2
leaq 0x14080(%rip), %rsi     # 0x33d6c
leaq 0x140b9(%rip), %rcx     # 0x33dac
movl $0x1eb, %edx            # imm = 0x1EB
callq 0x4180
movq 0x68(%rdi), %rax
movq (%rax), %rdi
movl (%rdi), %eax
andl $-0x2, %eax
cmpl $0x1c, %eax
je 0x1fcfd
movq %rdi, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fd59
movb 0x91(%rdi), %cl
testb %cl, %cl
jne 0x1fd4f
movq 0x78(%rdi), %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1fd47
movq 0x88(%rdi), %rdx
movq (%rdx,%rcx,8), %rdx
incq %rcx
cmpq $0x0, 0x28(%rdx)
je 0x1fd29
movb $0x2, %cl
jmp 0x1fd49
movb $0x1, %cl
movb %cl, 0x91(%rdi)
xorl %eax, %eax
cmpb $0x1, %cl
sete %al
popq %rcx
retq
leaq 0x1276b(%rip), %rdi     # 0x324cb
leaq 0x14005(%rip), %rsi     # 0x33d6c
leaq 0x14005(%rip), %rcx     # 0x33d73
pushq $0x3b
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 0x3f45f(%rip), %rdi     # 0x5f1e0
movq %rbx, %rsi
callq 0x2a3e8
testq %rax, %rax
je 0x1fdab
movb $0x1, %cl
cmpb $0x0, 0x96(%rbx)
jne 0x1fda3
cmpb $0x0, 0x96(%rax)
setne %cl
movb %cl, 0x96(%rbx)
jmp 0x1fdc0
movq 0x3f42e(%rip), %rdi     # 0x5f1e0
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x2a22a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fdec
movl %ebx, %eax
cmpq %rax, 0x3f40e(%rip)     # 0x5f1e8
jbe 0x1fdec
movq 0x3f3f5(%rip), %rcx     # 0x5f1d8
movq (%rcx,%rax,8), %r14
jmp 0x1fe6c
movl $0xa0, %edi
callq 0x29a78
movq %rax, %r14
movl %ebx, (%rax)
movq 0x3f3e6(%rip), %rax     # 0x5f1e8
leaq 0x1(%rax), %rcx
movq %rcx, 0x3f3db(%rip)     # 0x5f1e8
movl %eax, 0x4(%r14)
movq %r15, 0x8(%r14)
movq 0x3f3b4(%rip), %rdi     # 0x5f1d0
leaq 0x8(,%rax,8), %rsi
callq 0x29b04
movq %rax, 0x3f3a0(%rip)     # 0x5f1d0
movl 0x4(%r14), %ecx
andq $0x0, (%rax,%rcx,8)
movq 0x3f398(%rip), %rdi     # 0x5f1d8
movq 0x3f3a1(%rip), %rsi     # 0x5f1e8
shlq $0x3, %rsi
callq 0x29b04
movq %rax, 0x3f381(%rip)     # 0x5f1d8
movl 0x4(%r14), %ecx
movq %r14, (%rax,%rcx,8)
cmpl $0x11, %ebx
ja 0x1fe6c
movl $0x3, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1fdc2
movq %rax, %rbx
andw $0x0, 0x97(%rax)
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
shlq $0x3, %rsi
callq 0x29d0d
movq %rax, 0x40(%rbx)
movq 0x48(%r14), %rsi
movq %rsi, 0x48(%rbx)
movq 0x40(%r14), %rdi
shlq $0x3, %rsi
callq 0x29d0d
movq %rax, 0x50(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movq 0x68(%r14), %rdi
movq 0x70(%r14), %rsi
shlq $0x3, %rsi
callq 0x29d0d
movq %rax, 0x68(%rbx)
movq 0x70(%r14), %rax
movq %rax, 0x70(%rbx)
movq 0x78(%r14), %rsi
movq %rsi, 0x78(%rbx)
movl (%r14), %eax
addl $-0x15, %eax
cmpl $0x7, %eax
ja 0x1ff36
leaq 0x13cc1(%rip), %rcx     # 0x33bc0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%r14), %rax
jmp 0x1ff2f
movq 0x88(%r14), %rdi
shlq $0x3, %rsi
callq 0x29d0d
jmp 0x1ff2f
movq 0x88(%r14), %rdi
callq 0x4340
movq %rax, 0x88(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq