LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/ra.c
// Function: wladd
static void
wladd(Isel *s, regid u)
{
	size_t i;

	if (bshas(s->prepainted, u))
		return;
	if (moverelated(s, u))
		return;
	if (!istrivial(s, u))
		return;

	assert(locmap[u]->list == &s->wlfreeze || locmap[u]->list == &s->wlsimp);
	if (wlfind(s->wlfreeze, s->nwlfreeze, u, &i))
		wldel(s, &s->wlfreeze, &s->nwlfreeze, i);
	wlput(&s->wlsimp, &s->nwlsimp, locmap[u]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4c0(%rdi), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %rsi, %rcx
jbe 0xe5a1
movq 0x8(%rax), %rax
movq %r14, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r14, %rax
jb 0xe65c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe0c8
testl %eax, %eax
jne 0xe65c
movq 0x3d8(%rbx), %rdi
movq %r14, %rsi
callq 0xe08c
testl %eax, %eax
je 0xe65c
leaq 0x528ae(%rip), %r13     # 0x60e80
movq (%r13), %rax
movq (%rax,%r14,8), %r12
movq 0x8(%r12), %rax
leaq 0x480(%rbx), %rdi
cmpq %rdi, %rax
sete %cl
leaq 0x490(%rbx), %r15
cmpq %r15, %rax
sete %al
orb %cl, %al
je 0xe666
movq 0x488(%rbx), %rax
testq %rax, %rax
je 0xe642
movq 0x480(%rbx), %rcx
leaq 0x488(%rbx), %rsi
xorl %edx, %edx
movq (%rcx,%rdx,8), %r8
cmpq %r14, 0x10(%r8)
je 0xe62d
incq %rdx
cmpq %rdx, %rax
jne 0xe619
jmp 0xe642
movq $0x0, 0x8(%r8)
callq 0x2cfcc
movq (%r13), %rax
movq (%rax,%r14,8), %r12
addq $0x498, %rbx            # imm = 0x498
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2ceff
movq %r15, 0x8(%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2396d(%rip), %rdi     # 0x31fda
leaq 0x23850(%rip), %rsi     # 0x31ec4
leaq 0x239a0(%rip), %rcx     # 0x3201b
movl $0x336, %edx            # imm = 0x336
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/ra.c
// Function: mldel
static int
mldel(Insn ***ml, size_t *nml, Bitset *bs, Insn *m)
{
	size_t i;
	if (bshas(bs, m->uid)) {
		bsdel(bs, m->uid);
		for (i = 0; i < *nml; i++) {
			if (m == (*ml)[i]) {
				ldel(ml, nml, i);
				return 1;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rcx), %rsi
movq (%rdx), %rax
shlq $0x6, %rax
xorl %ebp, %ebp
cmpq %rsi, %rax
jbe 0xe943
movq %rcx, %r14
movq 0x8(%rdx), %rax
movq %rsi, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %rsi, %rax
jae 0xe943
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2d3d4
movq (%rbx), %rax
testq %rax, %rax
je 0xe943
movq (%r15), %rcx
xorl %edx, %edx
cmpq %r14, (%rcx,%rdx,8)
je 0xe933
incq %rdx
cmpq %rdx, %rax
jne 0xe921
xorl %ebp, %ebp
jmp 0xe943
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2cfcc
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/ra.c
// Function: mapfind
static Loc *
mapfind(Isel *s, Htab *map, Loc *old)
{
	Loc *new;
	Loc *base;
	Loc *idx;
	regid id;

	if (!old)
		return NULL;

	new = NULL;
	if (old->type == Locreg) {
		id = getalias(s, old->reg.id);
		new = htget(map, locmap[id]);
	} else if (old->type == Locmem || old->type == Locmeml) {
		base = old->mem.base;
		idx = old->mem.idx;
		if (base)
			base = locmap[getalias(s, base->reg.id)];
		if (idx)
			idx = locmap[getalias(s, idx->reg.id)];
		base = mapfind(s, map, base);
		idx = mapfind(s, map, idx);
		if (base != old->mem.base || idx != old->mem.idx) {
			if (old->type == Locmem)
				new = locmems(old->mem.constdisp, base, idx, old->mem.scale, old->mode);
			else
				new = locmemls(old->mem.lbldisp, base, idx, old->mem.scale, old->mode);
		}
	}
	if (new)
		return new;
	return old;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xea13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdx), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xea1a
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rax
testq %rdx, %rdx
je 0xea67
leaq 0x5249f(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq 0x10(%rdx), %rdx
movq 0x3d0(%r15), %rsi
cmpq %rsi, %rdx
jae 0xea0d
movq 0x3e8(%r15), %rdi
movq (%rdi,%rdx,8), %r8
testq %r8, %r8
je 0xea0d
movq 0x10(%r8), %rdx
cmpq %rsi, %rdx
jb 0xe9fb
movq (%rcx,%rdx,8), %rdx
jmp 0xea69
xorl %ebx, %ebx
jmp 0xeb10
cmpl $0x2, %eax
jne 0xeaef
movq 0x10(%rbx), %rax
movq 0x3d0(%r15), %rcx
cmpq %rcx, %rax
jae 0xea4c
movq 0x3e8(%r15), %rdx
movq (%rdx,%rax,8), %rsi
testq %rsi, %rsi
je 0xea4c
movq 0x10(%rsi), %rax
cmpq %rcx, %rax
jb 0xea3a
leaq 0x5242d(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x2d8fa
jmp 0xeb09
xorl %edx, %edx
testq %rax, %rax
je 0xeaa7
leaq 0x5240b(%rip), %rcx     # 0x60e80
movq (%rcx), %rcx
movq 0x10(%rax), %rax
movq 0x3d0(%r15), %rsi
cmpq %rsi, %rax
jae 0xeaa1
movq 0x3e8(%r15), %rdi
movq (%rdi,%rax,8), %r8
testq %r8, %r8
je 0xeaa1
movq 0x10(%r8), %rax
cmpq %rsi, %rax
jb 0xea8f
movq (%rcx,%rax,8), %r13
jmp 0xeaaa
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0xe9a8
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xe9a8
cmpq 0x28(%rbx), %r12
jne 0xead2
cmpq 0x30(%rbx), %rax
je 0xeaef
cmpl $0x3, (%rbx)
jne 0xeaf3
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0xa9b8
jmp 0xeb09
xorl %eax, %eax
jmp 0xeb09
movq 0x10(%rbx), %rdi
movl 0x20(%rbx), %ecx
movl 0x4(%rbx), %r8d
movq %r12, %rsi
movq %rax, %rdx
callq 0xaa4c
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/peep.c
// Function: peep
void
peep(Isel *s)
{
	size_t i;

	for (i = 0; i < s->nbb; i++) {
		deadcode(s, s->bb[i]);
		nopjmp(s, s->bb[i], i);
	}
}

// Assembly:
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0xec38
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdi), %r14
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %rbp
testq %rbp, %rbp
je 0xec1b
movq 0x20(%rbp), %rax
testq %rax, %rax
je 0xec1b
movq 0x18(%rbp), %rcx
movq %rax, %rdx
negq %rdx
movl $0x1, %ebx
movq -0x8(%rcx,%rbx,8), %rsi
cmpl $0x34, 0x8(%rsi)
je 0xeb8f
leaq (%rdx,%rbx), %rsi
incq %rsi
incq %rbx
cmpq $0x1, %rsi
jne 0xeb71
movq %rax, %rbx
movq %rbx, 0x20(%rbp)
movq 0x18(%rbp), %rax
movq -0x8(%rax,%rbx,8), %rax
cmpl $0x34, 0x8(%rax)
jne 0xec1b
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
jne 0xec1b
movq %r12, %rcx
cmpq %r8, %rcx
jae 0xec1b
movq (%r14,%rcx,8), %rdx
incq %rcx
testq %rdx, %rdx
je 0xebae
movq 0x10(%rdx), %rcx
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0xec1b
movq 0x8(%rdx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq %r8, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4230
testl %eax, %eax
je 0xec0f
incq %r15
cmpq %r15, 0x20(%rsp)
movq 0x8(%rsp), %r8
jne 0xebe7
jmp 0xec1b
decq %rbx
movq %rbx, 0x20(%rbp)
movq 0x8(%rsp), %r8
incq %r13
incq %r12
cmpq %r8, %r13
jne 0xeb48
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: loadvar
Node *
loadvar(Simp *s, Node *n, Node *dst)
{
	Node *p, *f, *r, *e;

	if (isconstfn(n)) {
		if (dst)
			r = dst;
		else
			r = temp(s, n);
		f = getcode(s, n);
		p = addr(s, r, exprtype(n));
		assignat(s, p, Ptrsz, f);
		e = mkintlit(n->loc, 0);
		e->expr.type = tyintptr;
		assignat(s, p, 0, e);
	} else {
		r = n;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28999
testl %eax, %eax
je 0xed0d
testq %rbx, %rbx
jne 0xecab
movq %r14, %rdi
movq %r15, %rsi
callq 0xed1a
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0xed94
movq %rax, %r12
movq %r15, %rdi
callq 0x1e384
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xee74
movq %rax, %r13
movl $0x8, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0xef42
movq (%r15), %rdi
xorl %esi, %esi
callq 0x1d57a
movq 0x52632(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xef42
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: temp
static Node *
temp(Simp *simp, Node *e)
{
	Node *t, *dcl;

	assert(e->type == Nexpr);
	t = gentemp(e->loc, e->expr.type, &dcl);
	if (stacknode(e))
		declarelocal(simp, dcl);
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x8, 0x8(%rsi)
jne 0xed75
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x20(%rsi), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1e0f5
movq %rax, %r14
xorl %eax, %eax
cmpl $0x8, 0x8(%r15)
setne %al
movq 0x20(%r15,%rax,8), %rdi
callq 0x22784
testl %eax, %eax
je 0xed68
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf5c4
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21fdc(%rip), %rdi     # 0x30d58
leaq 0x23561(%rip), %rsi     # 0x322e4
leaq 0x23561(%rip), %rcx     # 0x322eb
movl $0x11c, %edx            # imm = 0x11C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: getcode
static Node *
getcode(Simp *s, Node *n)
{
	Node *r, *p, *d;
	Type *ty;

	if (isconstfn(n)) {
		d = decls[n->expr.did];
		r = mkexpr(n->loc, Ovar, n->expr.args[0], NULL);
		r->expr.did = d->decl.did;
		r->expr.type = codetype(exprtype(n));
	} else {
		ty = tybase(exprtype(n));
		assert(ty->type == Tyfunc);
		p = addr(s, rval(s, n, NULL), codetype(ty));
		r = load(addk(p, Ptrsz));
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28999
testl %eax, %eax
je 0xedfd
leaq 0x52bb6(%rip), %rax     # 0x61968
movq (%rax), %rax
movq (%rbx), %rdi
movq 0x38(%rbx), %rcx
movq (%rax,%rcx,8), %r15
movq 0x50(%rbx), %rax
movq (%rax), %rdx
movl $0x33, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r14
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
movq %rbx, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x5543
movq %rax, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
cmpl $0x13, (%rax)
jne 0xee55
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xf923
movq %rax, %rbx
movq %r15, %rdi
callq 0x5543
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xee74
movl $0x8, %esi
movq %rax, %rdi
callq 0x10a5e
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x109e7
leaq 0x2362f(%rip), %rdi     # 0x3248b
leaq 0x23481(%rip), %rsi     # 0x322e4
leaq 0x23634(%rip), %rcx     # 0x3249e
movl $0x41e, %edx            # imm = 0x41E
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: addr
static Node *
addr(Simp *s, Node *a, Type *bt)
{
	Node *n;

	n = mkexpr(a->loc, Oaddr, a, NULL);
	if (!addressable(s, a))
		forcelocal(s, a);
	if (!bt)
		n->expr.type = mktyptr(a->loc, a->expr.type);
	else
		n->expr.type = mktyptr(a->loc, bt);
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rdi
movl $0x12, %esi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %rbx
movl 0x8(%r15), %eax
cmpl $0xb, %eax
je 0xeeb7
cmpl $0x8, %eax
jne 0xeef5
movq %r15, %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0xeef1
movq 0x50(%r12), %rdi
movq %r15, %rsi
callq 0x2da24
testl %eax, %eax
jne 0xef16
movq 0x48(%r12), %rdi
movq %r15, %rsi
callq 0x2da24
testl %eax, %eax
jne 0xef16
movq 0x40(%r12), %rdi
movq %r15, %rsi
callq 0x2da24
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0xef07
movl 0x8(%r15), %eax
xorl %ecx, %ecx
cmpl $0x8, %eax
setne %cl
movq 0x20(%r15,%rcx,8), %rdi
callq 0x22784
testl %eax, %eax
jne 0xef16
movq %r12, %rdi
movq %r15, %rsi
callq 0xf641
testq %r14, %r14
je 0xef23
movq (%r15), %rdi
movq %r14, %rsi
jmp 0xef2a
movq (%r15), %rdi
movq 0x20(%r15), %rsi
callq 0x22d0e
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: assignat
static Node *
assignat(Simp *s, Node *r, size_t off, Node *val)
{
	Node *pval, *pdst;
	Node *sz;
	Node *st;

	pdst = add(r, disp(val->loc, off));

	if (stacknode(val)) {
		sz = disp(val->loc, size(val));
		pval = addr(s, val, exprtype(val));
		st = mkexpr(val->loc, Oblit, pdst, pval, sz, NULL);
	} else {
		st = set(deref(pdst, val->expr.type), val);
	}
	append(s, st);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rcx), %rdi
movl %edx, %esi
callq 0x1d57a
movq 0x523c3(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf71b
movq %rax, %r12
xorl %eax, %eax
cmpl $0x8, 0x8(%r15)
setne %al
movq 0x20(%r15,%rax,8), %rdi
callq 0x22784
testl %eax, %eax
je 0xefe2
movq %r15, %rdi
callq 0x12664
movq (%r15), %rdi
movl %eax, %esi
callq 0x1d57a
movq %rax, %r13
movq 0x5237d(%rip), %rax     # 0x61328
movq %rax, 0x20(%r13)
movq %r15, %rdi
callq 0x1e384
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xee74
movq (%r15), %rdi
movl $0x46, %esi
movq %r12, %rdx
movq %rax, %rcx
movq %r13, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d5e2
jmp 0xeff9
movq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0xf833
movq %rax, %rdi
movq %r15, %rsi
callq 0xf780
movq %r14, %rdi
movq %rax, %rsi
callq 0xf8bb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: declarelocal
static void
declarelocal(Simp *s, Node *n)
{
	if (n->type == Nexpr)
		n = decls[n->decl.did];
	if (n->decl.isconst && n->decl.isextern)
		htput(s->globls, n, asmname(n));
	else if (stacknode(n))
		forcelocal(s, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, 0x8(%rsi)
jne 0xf5e6
leaq 0x5238d(%rip), %rax     # 0x61968
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rbx
cmpb $0x0, 0x72(%rbx)
je 0xf613
cmpb $0x0, 0x74(%rbx)
je 0xf613
movq 0x40(%r14), %r14
movq %rbx, %rdi
callq 0x5584
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d71e
xorl %eax, %eax
cmpl $0x8, 0x8(%rbx)
setne %al
movq 0x20(%rbx,%rax,8), %rdi
callq 0x22784
testl %eax, %eax
je 0xf639
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf641
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: forcelocal
static void
forcelocal(Simp *s, Node *n)
{
	assert(n->type == Ndecl || (n->type == Nexpr && exprop(n) == Ovar));
	s->stksz += size(n);
	s->stksz = align(s->stksz, min(size(n), Ptrsz));
	if (debugopt['i']) {
		dumpn(n, stdout);
		printf("declared at %zd, size = %zd\n", s->stksz, size(n));
	}
	htput(s->stkoff, n, itop(s->stksz));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
cmpl $0xb, %eax
je 0xf66e
cmpl $0x8, %eax
jne 0xf6fc
movq %rbx, %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0xf6fc
movq %rbx, %rdi
callq 0x12664
movq %rax, %r15
addq 0x58(%r14), %r15
movq %r15, 0x58(%r14)
movq %rbx, %rdi
callq 0x12664
movl $0x8, %esi
movq %rax, %rdi
callq 0x2e20c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2e217
movq %rax, 0x58(%r14)
leaq 0x51b34(%rip), %rcx     # 0x611e0
cmpb $0x0, 0x69(%rcx)
je 0xf6e8
movq 0x34917(%rip), %rax     # 0x43fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x13806
movq 0x58(%r14), %r15
movq %rbx, %rdi
callq 0x12664
leaq 0x22c8b(%rip), %rdi     # 0x32362
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4140
movq 0x58(%r14), %rax
movq 0x48(%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2d71e
leaq 0x22c03(%rip), %rdi     # 0x32306
leaq 0x22bda(%rip), %rsi     # 0x322e4
leaq 0x22c31(%rip), %rcx     # 0x32342
movl $0xab, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: add
static Node *
add(Node *a, Node *b)
{
	Node *n;

	assert(size(a) == size(b));
	n = mkexpr(a->loc, Oadd, a, b, NULL);
	n->expr.type = a->expr.type;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x12664
movq %rax, %r15
movq %r14, %rdi
callq 0x12664
cmpq %rax, %r15
jne 0xf761
movq (%rbx), %rdi
movl $0x2, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x22c17(%rip), %rdi     # 0x3237f
leaq 0x22b75(%rip), %rsi     # 0x322e4
leaq 0x22c1c(%rip), %rcx     # 0x32392
movl $0x69, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: set
static Node *
set(Node *a, Node *b)
{
	Node *n;

	assert(a != NULL && b != NULL);
	assert(exprop(a) == Ovar || exprop(a) == Oderef);
	if (tybase(exprtype(a))->type == Tyvoid)
		return a;

	n = mkexpr(a->loc, Oset, a, b, NULL);
	n->expr.type = exprtype(a);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf7f5
movq %rsi, %r14
testq %rsi, %rsi
je 0xf7f5
movq %rdi, %rbx
callq 0x1d422
cmpl $0x33, %eax
je 0xf7ab
movq %rbx, %rdi
callq 0x1d422
cmpl $0x13, %eax
jne 0xf814
movq %rbx, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
cmpl $0x1, (%rax)
je 0xf7ea
movq (%rbx), %rdi
movl $0x40, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e384
movq %rax, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22bb0(%rip), %rdi     # 0x323ac
leaq 0x22ae1(%rip), %rsi     # 0x322e4
leaq 0x22bb9(%rip), %rcx     # 0x323c3
movl $0xef, %edx
callq 0x4180
leaq 0x22bc2(%rip), %rdi     # 0x323dd
leaq 0x22ac2(%rip), %rsi     # 0x322e4
leaq 0x22b9a(%rip), %rcx     # 0x323c3
movl $0xf0, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: deref
static Node *
deref(Node *a, Type *t)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	if (t)
		n->expr.type = t;
	else
		n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0xf87d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x13, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
testq %rbx, %rbx
jne 0xf871
movq 0x20(%r14), %rcx
cmpq $0x1, 0x70(%rcx)
jne 0xf89c
movq 0x68(%rcx), %rcx
movq (%rcx), %rbx
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22b82(%rip), %rdi     # 0x32406
leaq 0x22a59(%rip), %rsi     # 0x322e4
leaq 0x22b90(%rip), %rcx     # 0x32422
movl $0xe1, %edx
callq 0x4180
leaq 0x22b9b(%rip), %rdi     # 0x3243e
leaq 0x22a3a(%rip), %rsi     # 0x322e4
leaq 0x22b9a(%rip), %rcx     # 0x3244b
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: append
static void
append(Simp *s, Node *n)
{
	if (debugopt['S'])
		dumpn(n, stdout);
        assert(n->type != Ndecl);
	lappend(&s->stmts, &s->nstmts, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x51914(%rip), %rax     # 0x611e0
cmpb $0x0, 0x53(%rax)
je 0xf8e4
movq 0x346f7(%rip), %rax     # 0x43fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x13806
cmpl $0xb, 0x8(%rbx)
je 0xf904
leaq 0x8(%r14), %rdi
addq $0x10, %r14
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ceff
leaq 0x22b53(%rip), %rdi     # 0x3245e
leaq 0x229d2(%rip), %rsi     # 0x322e4
leaq 0x22b56(%rip), %rcx     # 0x3246f
movl $0x4d, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: load
static Node *
load(Node *a)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0x10a20
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x13, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq 0x20(%rbx), %rcx
cmpq $0x1, 0x70(%rcx)
jne 0x10a3f
movq 0x68(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
retq
leaq 0x219df(%rip), %rdi     # 0x32406
leaq 0x218b6(%rip), %rsi     # 0x322e4
leaq 0x21c18(%rip), %rcx     # 0x3264d
movl $0xd6, %edx
callq 0x4180
leaq 0x219f8(%rip), %rdi     # 0x3243e
leaq 0x21897(%rip), %rsi     # 0x322e4
leaq 0x219f7(%rip), %rcx     # 0x3244b
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: idxaddr
static Node *
idxaddr(Simp *s, Node *seq, Node *idx)
{
	Node *a, *t, *u, *v, *w; /* temps */
	Node *r; /* result */
	Type *ty, *seqty;
	size_t sz;

	a = rval(s, seq, NULL);
	seqty = tybase(exprtype(seq));
	ty = seqty->sub[0];
	if (seqty->type == Tyarray) {
		t = addr(s, a, ty);
		w = seqty->asize;
	} else if (seqty->type == Tyslice) {
		t = load(addr(s, a, mktyptr(seq->loc, ty)));
		w = slicelen(s, a);
	} else {
		die("can't index type %s", tystr(seq->expr.type));
	}
	assert(exprtype(t)->type == Typtr);
	u = rval(s, idx, NULL);
	u = ptrsized(s, u);
	checkidx(s, Olt, w, u);
	sz = tysize(ty);
	v = mul(u, disp(seq->loc, sz));
	r = add(t, v);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xf923
movq %rax, %rbp
movq %rbx, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
movq %rax, %r15
movq 0x68(%rax), %rax
movq (%rax), %r12
movl (%r15), %eax
cmpl $0x14, %eax
je 0x10af2
cmpl $0x15, %eax
jne 0x10bd6
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xee74
movq %rax, %r13
movq 0x88(%r15), %rbp
jmp 0x10b24
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x22d0e
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xee74
movq %rax, %rdi
callq 0x109e7
movq %rax, %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x116bc
movq %rax, %rbp
movq %r13, %rdi
callq 0x1e384
cmpl $0x12, (%rax)
jne 0x10bb7
movq %r14, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xf923
movq %rax, %rdi
callq 0x1156c
movq %rax, %r15
movq %r14, %rdi
movl $0x1b, %esi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x115c3
movq %r12, %rdi
callq 0x12421
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d57a
movq 0x507ae(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%r15), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq 0x20(%r15), %rcx
movq %rcx, 0x20(%rax)
movq %r13, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf71b
leaq 0x219bc(%rip), %rdi     # 0x3257a
leaq 0x2171f(%rip), %rsi     # 0x322e4
leaq 0x219c9(%rip), %rcx     # 0x32595
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x4180
movq 0x20(%rbx), %rdi
callq 0x2398e
leaq 0x21980(%rip), %rdi     # 0x32566
movq %rax, %rsi
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: seqlen
static Node *
seqlen(Simp *s, Node *n, Type *ty)
{
	Node *t, *r;

        r = NULL;
	if (exprtype(n)->type == Tyslice) {
		t = slicelen(s, n);
		r = simpcast(s, t, ty);
	} else if (exprtype(n)->type == Tyarray) {
		t = exprtype(n)->asize;
                if (t)
                    r = simpcast(s, t, ty);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e384
cmpl $0x14, (%rax)
jne 0x10c1e
movq %r14, %rdi
movq %r15, %rsi
callq 0x116bc
movq %r14, %rdi
movq %rax, %rsi
jmp 0x10c42
movq %r15, %rdi
callq 0x1e384
cmpl $0x15, (%rax)
jne 0x10c4c
movq %r15, %rdi
callq 0x1e384
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0x10c4c
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10c54
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: simpblob
static Node *
simpblob(Simp *s, Node *blob)
{
	Node *r, *d;

	r = geninitdecl(blob, exprtype(blob), &d);
	htput(s->globls, d, asmname(d));
	lappend(&s->blobs, &s->nblobs, d);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e384
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1176b
movq %rax, %r14
movq 0x40(%rbx), %r12
movq (%r15), %r13
movq %r13, %rdi
callq 0x5584
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2d71e
leaq 0x30(%rbx), %rdi
addq $0x38, %rbx
movq (%r15), %rdx
movq %rbx, %rsi
callq 0x2ceff
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: assign
static Node *
assign(Simp *s, Node *lhs, Node *rhs)
{
	Node *t, *u, *v, *r;

	t = lval(s, lhs);
	u = rval(s, rhs, t);

	if (tybase(exprtype(lhs))->type == Tyvoid)
		return u;

	/* hack: we're assigning to lhs, but blitting shit over doesn't
	 * trigger that */
	if (stacknode(lhs))
		def(s, lhs);
	/* if we stored the result into t, rval() should return that,
	 * so we know our work is done. */
	if (u == t) {
		r = t;
	} else if (stacknode(lhs)) {
		t = addr(s, t, exprtype(lhs));
		u = addr(s, u, exprtype(lhs));
		v = disp(lhs->loc, size(lhs));
		r = mkexpr(lhs->loc, Oblit, t, u, v, NULL);
		r->expr.type = exprtype(lhs);
	} else {
		r = set(t, u);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x11288
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf923
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
cmpl $0x1, (%rax)
je 0x11263
xorl %eax, %eax
cmpl $0x8, 0x8(%rbx)
setne %al
movq 0x20(%rbx,%rax,8), %rdi
callq 0x22784
testl %eax, %eax
je 0x111c1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11892
cmpq %r12, %r14
je 0x11260
xorl %eax, %eax
cmpl $0x8, 0x8(%rbx)
setne %al
movq 0x20(%rbx,%rax,8), %rdi
callq 0x22784
testl %eax, %eax
je 0x11272
movq %rbx, %rdi
callq 0x1e384
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xee74
movq %rax, %r12
movq %rbx, %rdi
callq 0x1e384
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xee74
movq %rax, %r14
movq %rbx, %rdi
callq 0x12664
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d57a
movq 0x500f8(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%rbx), %rdi
movl $0x46, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e384
movq %rax, 0x20(%r14)
jmp 0x11263
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf780
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: lval
static Node *
lval(Simp *s, Node *n)
{
	Node *r;
	Node **args;

	args = n->expr.args;
	switch (exprop(n)) {
	case Ovar:	r = loadvar(s, n, NULL);	break;
	case Oidx:	r = loadidx(s, args[0], args[1]);	break;
	case Oderef:	r = deref(rval(s, args[0], NULL), NULL);	break;
	case Otupmemb:	r = rval(s, n, NULL);	break;
	case Omemb:	r = rval(s, n, NULL);	break;
	case Ostruct:	r = rval(s, n, NULL);	break;
	case Oucon:	r = rval(s, n, NULL);	break;
	case Oarr:	r = rval(s, n, NULL);	break;

	/*
	  not expressible as lvalues in syntax, but
	  we take their address in matches
	 */
	case Oudata:    r = rval(s, n, NULL); break;
	case Outag:     r = rval(s, n, NULL); break;
	case Otupget:   r = rval(s, n, NULL); break;

	default:
			fatal(n, "%s cannot be an lvalue", opstr[exprop(n)]);
			break;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %r15
movq %rsi, %rdi
callq 0x1d422
cmpl $0x32, %eax
jle 0x112d7
cmpl $0x42, %eax
jg 0x11307
addl $-0x33, %eax
cmpl $0x6, %eax
ja 0x11350
leaq 0x2100c(%rip), %rcx     # 0x322c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xec7a
cmpl $0x29, %eax
jg 0x11318
cmpl $0x13, %eax
je 0x11334
cmpl $0x28, %eax
jne 0x11350
movq (%r15), %rsi
movq 0x8(%r15), %rbx
movq %r14, %rdi
xorl %edx, %edx
callq 0xf923
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x10a8e
jmp 0x11341
cmpl $0x43, %eax
je 0x11322
cmpl $0x44, %eax
je 0x11322
cmpl $0x45, %eax
je 0x11322
jmp 0x11350
cmpl $0x2a, %eax
je 0x11322
cmpl $0x2b, %eax
jne 0x11350
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xf923
movq (%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xf923
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xf833
movq %rbx, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x4f03f(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rdx
leaq 0x212ca(%rip), %rsi     # 0x32636
movq %rbx, %rdi
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: visit
static Node *
visit(Simp *s, Node *n)
{
	size_t i;
	Node *r;

	for (i = 0; i < n->expr.nargs; i++)
		n->expr.args[i] = rval(s, n->expr.args[i], NULL);
	if (ispure(n)) {
		r = n;
	} else {
		if (exprtype(n)->type == Tyvoid) {
			r = NULL;
			append(s, n);
		} else {
			r = temp(s, n);
			append(s, set(r, n));
		}
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x40(%rsi)
je 0x113ae
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xf923
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x1138b
movq %rbx, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x4f5e1(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
jne 0x11408
movq %rbx, %rdi
callq 0x1e384
cmpl $0x1, (%rax)
jne 0x113e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf8bb
xorl %ebx, %ebx
jmp 0x11408
movq %r14, %rdi
movq %rbx, %rsi
callq 0xed1a
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf780
movq %r14, %rdi
movq %rax, %rsi
callq 0xf8bb
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: slicebase
static Node *
slicebase(Simp *s, Node *n, Node *off)
{
	Node *u, *v;
	Type *ty;
	int sz;

	u = NULL;
	ty = tybase(exprtype(n));
	switch (ty->type) {
	case Typtr:	u = n;	break;
	case Tyslice:	u = load(addr(s, n, mktyptr(n->loc, base(exprtype(n)))));	break;
	case Tyarray:	u = addr(s, n, base(exprtype(n)));	break;
	default: die("Unslicable type %s", tystr(n->expr.type));
	}
	/* safe: all types we allow here have a sub[0] that we want to grab */
	if (off) {
		off = ptrsized(s, rval(s, off, NULL));
		sz = tysize(n->expr.type->sub[0]);
		v = mul(off, disp(n->loc, sz));
		return add(u, v);
	} else {
		return u;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
movl (%rax), %eax
movq %rbx, %r12
cmpl $0x12, %eax
je 0x114ac
cmpl $0x15, %eax
je 0x11484
cmpl $0x14, %eax
jne 0x11552
movq %rbx, %rdi
callq 0x1e384
cmpq $0x1, 0x70(%rax)
jne 0x11533
movq 0x68(%rax), %rax
movq (%rax), %rsi
movq (%rbx), %rdi
callq 0x22d0e
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xee74
movq %rax, %rdi
callq 0x109e7
jmp 0x114a9
movq %rbx, %rdi
callq 0x1e384
cmpq $0x1, 0x70(%rax)
jne 0x11533
movq 0x68(%rax), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xee74
movq %rax, %r12
testq %r14, %r14
je 0x11524
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf923
movq %rax, %rdi
callq 0x1156c
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x12421
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d57a
movq 0x4fe3e(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%r14), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf71b
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20f04(%rip), %rdi     # 0x3243e
leaq 0x20da3(%rip), %rsi     # 0x322e4
leaq 0x20f03(%rip), %rcx     # 0x3244b
movl $0x60, %edx
callq 0x4180
movq 0x20(%rbx), %rdi
callq 0x2398e
leaq 0x20ff1(%rip), %rdi     # 0x32553
movq %rax, %rsi
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: ptrsized
static Node *
ptrsized(Simp *s, Node *v)
{
	if (size(v) == Ptrsz)
		return v;
	else if (size(v) < Ptrsz)
		v = mkexpr(v->loc, Ozwiden, v, NULL);
	else if (size(v) > Ptrsz)
		v = mkexpr(v->loc, Otrunc, v, NULL);
	v->expr.type = tyintptr;
	return v;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x12664
cmpq $0x8, %rax
je 0x115be
movq %rbx, %rdi
callq 0x12664
movl $0x4a, %esi
cmpq $0x8, %rax
jb 0x115a1
movq %rbx, %rdi
callq 0x12664
movl $0x49, %esi
cmpq $0x9, %rax
jb 0x115b3
movq (%rbx), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %rbx
movq 0x4fd6e(%rip), %rax     # 0x61328
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: checkidx
static void
checkidx(Simp *s, Op op, Node *len, Node *idx)
{
	Node *cmp, *die, *jmp;
	Node *ok, *fail;

	if (!len)
		return;
	/* create expressions */
	cmp = mkexpr(idx->loc, op, ptrsized(s, idx), ptrsized(s, len), NULL);
	cmp->expr.type = mktype(len->loc, Tybool);
	ok = genlbl(len->loc);
	fail = genlbl(len->loc);
	die = mkexpr(idx->loc, Ocall, abortoob, NULL);
	die->expr.type = mktype(len->loc, Tyvoid);

	/* insert them */
	jmp = mkexpr(idx->loc, Ocjmp, cmp, ok, fail, NULL);
	append(s, jmp);
	append(s, fail);
	append(s, die);
	append(s, ok);
}

// Assembly:
testq %rdx, %rdx
je 0x116bb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x1156c
movq %rax, %r12
movq %r15, %rdi
callq 0x1156c
movq (%r14), %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r13
movq (%r15), %rdi
movl $0x2, %esi
callq 0x2289d
movq %rax, 0x20(%r13)
movq (%r15), %rdi
callq 0x1de03
movq %rax, (%rsp)
movq (%r15), %rdi
callq 0x1de03
movq %rax, %rbp
movq 0x4fd04(%rip), %rdx     # 0x61340
movq (%r14), %rdi
movl $0x2d, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r12
movq (%r15), %rdi
movl $0x1, %esi
callq 0x2289d
movq %rax, 0x20(%r12)
movq (%r14), %rdi
movl $0x3e, %esi
movq %r13, %rdx
movq (%rsp), %r14
movq %r14, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d5e2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf8bb
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf8bb
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf8bb
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf8bb
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: intconvert
static Node *
intconvert(Simp *s, Node *from, Type *to, int issigned)
{
	Node *r;
	size_t fromsz, tosz;

	fromsz = size(from);
	tosz = tysize(to);
	r = rval(s, from, NULL);
	if (fromsz > tosz) {
		r = mkexpr(from->loc, Otrunc, r, NULL);
	} else if (tosz > fromsz) {
		if (issigned)
			r = mkexpr(from->loc, Oswiden, r, NULL);
		else
			r = mkexpr(from->loc, Ozwiden, r, NULL);
	}
	r->expr.type = to;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x12664
movq %rax, %r12
movq %rbx, %rdi
callq 0x12421
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf923
cmpq %r13, %r12
jbe 0x11737
movq (%r14), %rdi
movl $0x49, %esi
jmp 0x1174c
jae 0x11758
movq (%r14), %rdi
testl %ebp, %ebp
je 0x11747
movl $0x4b, %esi
jmp 0x1174c
movl $0x4a, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: geninitdecl
static Node *
geninitdecl(Node *init, Type *ty, Node **dcl)
{
	Node *n, *d, *r;
	char lbl[128];

	n = mkname(init->loc, genlblstr(lbl, 128, ""));
	d = mkdecl(init->loc, n, ty);
	r = mkexpr(init->loc, Ovar, n, NULL);

	d->decl.init = init;
	d->decl.type = ty;
	d->decl.isconst = 1;
	d->decl.isglobl = 1;

	r->expr.did = d->decl.did;
	r->expr.type = ty;
	r->expr.isconst = 1;
	if (dcl)
		*dcl = d;
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x206bf(%rip), %rdx     # 0x31e4a
movq %rsp, %rdi
movl $0x80, %esi
callq 0x1dda3
movq (%r15), %rdi
movq %rax, %rsi
callq 0x1d6f5
movq %rax, %r13
movq (%r15), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1e04f
movq %rax, %r12
movq (%r15), %rdi
movl $0x33, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %r15, 0x30(%r12)
movq %r14, 0x28(%r12)
movw $0x101, 0x71(%r12)      # imm = 0x101
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%rax)
movq %r14, 0x20(%rax)
movl $0x1, 0x30(%rax)
testq %rbx, %rbx
je 0x117f9
movq %r12, (%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: simpcode
static Node *
simpcode(Simp *s, Node *fn)
{
	Node *r, *d;

	r = geninitdecl(fn, codetype(exprtype(fn)), &d);
	r->decl.isconst = 1;
	r->decl.isglobl = 1;
	htput(s->globls, d, asmname(d));
	lappend(&file.stmts, &file.nstmts, d);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x5543
movq %rsp, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1176b
movq %rax, %rbx
movw $0x101, 0x71(%rax)      # imm = 0x101
movq 0x40(%r14), %r14
movq (%r15), %r12
movq %r12, %rdi
callq 0x5584
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2d71e
movq (%r15), %rdx
leaq 0x4fa0f(%rip), %rsi     # 0x61278
leaq 0x40(%rsi), %rdi
addq $0x48, %rsi
callq 0x2ceff
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: vatypeinfo
static Node *
vatypeinfo(Simp *s, Node *n)
{
	Node *ti, *tp, *td, *tn;
	Type *ft, *vt, **st;
	size_t nst, i;
	char buf[1024];

	st = NULL;
	nst = 0;
	ft = exprtype(n->expr.args[0]);
	/* The structure of ft->sub:
	 *   [return, normal, args, ...]
	 *
	 * The structure of n->expr.sub:
	 *    [fn, normal, args, , variadic, args]
	 *
	 * We want to start at variadic, so we want
	 * to count from ft->nsub - 1, up to n->expr.nsub.
	 */
	for (i = ft->nsub - 1; i < n->expr.nargs; i++) {
		lappend(&st, &nst, exprtype(n->expr.args[i]));
	}
	vt = mktytuple(n->loc, st, nst);
	tagreflect(vt);

	/* make the decl */
	tn = mkname(Zloc, tydescid(buf, sizeof buf, vt));
	td = mkdecl(Zloc, tn, mktype(n->loc, Tybyte));
	td->decl.isglobl = 1;
	td->decl.isconst = 1;
	td->decl.ishidden = 1;

	/* and the var */
	ti = mkexpr(Zloc, Ovar, tn, NULL);
	ti->expr.type = td->decl.type;
	ti->expr.did = td->decl.did;

	/* and the pointer */
	tp = mkexpr(Zloc, Oaddr, ti, NULL);
	tp->expr.type = mktyptr(n->loc, td->decl.type);

	htput(s->globls, td, asmname(td));
	return tp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rsp)
movq %r15, (%rsp)
movq 0x50(%rsi), %rax
movq (%rax), %rdi
callq 0x1e384
movq 0x70(%rax), %r13
decq %r13
movl $0x0, %esi
cmpq 0x40(%r14), %r13
jae 0x119a9
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x50(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e384
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2ceff
incq %r13
cmpq 0x40(%r14), %r13
jb 0x1197c
movq 0x8(%rsp), %rsi
movq (%rsp), %r15
movq (%r14), %rdi
movq %r15, %rdx
callq 0x22d46
movq %rax, %r15
movq %rax, %rdi
callq 0x13a50
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x579f
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rsi
callq 0x1d6f5
movq %rax, %r12
movq (%r14), %rdi
movl $0x9, %esi
callq 0x2289d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e04f
movq %rax, %r15
movw $0x101, 0x71(%rax)      # imm = 0x101
movb $0x1, 0x76(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x38(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x12, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r12
movq 0x28(%r15), %rsi
movq (%r14), %rdi
callq 0x22d0e
movq %rax, 0x20(%r12)
movq 0x40(%rbx), %rbx
movq %r15, %rdi
callq 0x5584
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d71e
movq %r12, %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: simp
static Node *
simp(Simp *s, Node *n)
{
	Node *r;

	if (!n)
		return NULL;
	r = NULL;
	switch (n->type) {
	case Nblock:	simpblk(s, n);	break;
	case Ndecl:     declarelocal(s, n);     break;
	case Nexpr:
		if (islbl(n))
			append(s, n);
		else
			r = rval(s, n, NULL);
		if (r)
			append(s, r);
		break;
	default:
		dumpn(n, stderr);
		die("bad node passsed to simp()");
		break;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x11baa
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0xb, %eax
je 0x11b78
cmpl $0x8, %eax
je 0x11b50
cmpl $0x1, %eax
jne 0x11bb0
cmpq $0x0, 0x20(%r14)
je 0x11baa
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x144db
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x11ae6
incq %r15
cmpq 0x20(%r14), %r15
jb 0x11b1e
jmp 0x11baa
movq %r14, %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x11b88
movq 0x50(%r14), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x11b88
cmpl $0x6, 0x18(%rax)
jne 0x11b88
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x11ba0
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xf5c4
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf923
testq %rax, %rax
je 0x11baa
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xf8bb
popq %rbx
popq %r14
popq %r15
retq
movq 0x32439(%rip), %rax     # 0x43ff0
movq (%rax), %rsi
movq %r14, %rdi
callq 0x13806
leaq 0x20af5(%rip), %rdi     # 0x326be
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/simp.c
// Function: extractsub
static void
extractsub(Simp *s, Node *e)
{
	size_t i;
	Node *sub;

	assert(e != NULL);
	switch (exprop(e)) {
	case Oslice:
		sub = e->expr.args[0];
		extractsub(s, sub);
		if (exprop(sub) == Oarr) {
			if (sub->expr.nargs > 0) {
				e->expr.args[0] = simpblob(s, e->expr.args[0]);
			} else  {
				e->expr.args[0] = mkintlit(e->loc, 0);
				e->expr.args[0]->expr.type = tyintptr;
			}
		}
		break;
	case Oarr:
	case Ostruct:
		for (i = 0; i < e->expr.nargs; i++)
			extractsub(s, e->expr.args[i]);
		break;
	case Oucon:
		if (e->expr.nargs == 2)
			extractsub(s, e->expr.args[1]);
		break;
	default:
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x11c05
movq %rsi, %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x1d422
cmpl $0x36, %eax
jne 0x11c24
cmpq $0x2, 0x40(%rbx)
jne 0x11cbb
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rbx
testq %rbx, %rbx
jne 0x11be0
leaq 0x20b0d(%rip), %rdi     # 0x32719
leaq 0x206d1(%rip), %rsi     # 0x322e4
leaq 0x20b09(%rip), %rcx     # 0x32723
movl $0x60c, %edx            # imm = 0x60C
callq 0x4180
leal -0x38(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11c55
cmpq $0x0, 0x40(%rbx)
je 0x11cbb
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x11bd0
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x11c3a
jmp 0x11cbb
cmpl $0x29, %eax
jne 0x11cbb
movq 0x50(%rbx), %rax
movq (%rax), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x11bd0
movq %r15, %rdi
callq 0x1d422
cmpl $0x39, %eax
jne 0x11cbb
cmpq $0x0, 0x40(%r15)
je 0x11c98
movq 0x50(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x10e21
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
jmp 0x11cbb
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1d57a
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x4f678(%rip), %rax     # 0x61328
movq 0x50(%rbx), %rcx
movq (%rcx), %rcx
movq %rax, 0x20(%rcx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: blobsz
size_t
blobsz(Blob *b)
{
	size_t n;
	size_t i;

	switch (b->type) {
	case Bti8:	return 1;	break;
	case Bti16:	return 2;	break;
	case Bti32:	return 4;	break;
	case Bti64:	return 8;	break;
	case Btref:	return 8;	break;
	case Btbytes:	return b->bytes.len;	break;
	case Btimin:
		if (b->ival >= 1ULL << 56)
			die("packed int too big");

		for (i = 1; i < 8; i++)
			if (b->ival < 1ULL << (7*i))
				return i;
		die("impossible blob size");
		break;
	case Btseq:
		n = 0;
		for (i = 0; i < b->seq.nsub; i++)
			n += blobsz(b->seq.sub[i]);
		return n;
		break;
	default:
			die("unknown blob type");
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpq $0x7, %rax
ja 0x11d7c
movq %rdi, %r14
leaq 0x20a65(%rip), %rcx     # 0x32744
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %ebx
jmp 0x11d73
movl $0x4, %ebx
jmp 0x11d73
cmpq $0x0, 0x20(%r14)
je 0x11d71
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x11cc4
addq %rax, %rbx
incq %r15
cmpq 0x20(%r14), %r15
jb 0x11d05
jmp 0x11d73
movq 0x20(%r14), %rax
movq %rax, %rcx
shrq $0x38, %rcx
jne 0x11d85
movl $0x1, %ebx
movl $0x7, %ecx
movq %rax, %rdx
shrq %cl, %rdx
testq %rdx, %rdx
je 0x11d73
incq %rbx
addq $0x7, %rcx
cmpq $0x8, %rbx
jne 0x11d37
leaq 0x20bb5(%rip), %rdi     # 0x3290b
xorl %eax, %eax
callq 0x13844
movl $0x1, %ebx
jmp 0x11d73
movl $0x2, %ebx
jmp 0x11d73
movq 0x20(%r14), %rbx
jmp 0x11d73
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20b9d(%rip), %rdi     # 0x32920
jmp 0x11d56
leaq 0x20b6c(%rip), %rdi     # 0x328f8
jmp 0x11d56
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/6/typeinfo.c
// Function: namevec
void
namevec(Blob ***sub, size_t *nsub, Node *n)
{
	char *buf;
	size_t len;

	if (n->name.ns) {
		len = strlen(n->name.name) + strlen(n->name.ns) + 1;
		buf = xalloc(len + 1);
		bprintf(buf, len + 1, "%s.%s", n->name.ns, n->name.name);
	} else {
		len = strlen(n->name.name);
		buf = xalloc(len + 1);
		bprintf(buf, len + 1, "%s", n->name.name);
	}
	lappend(sub, nsub, mkblobi(Btimin, len));
	lappend(sub, nsub, mkblobbytes(buf, len));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdx), %r15
movq 0x20(%rdx), %rdi
callq 0x4120
movq %rax, %rbp
testq %r15, %r15
je 0x11df6
movq %r15, %rdi
callq 0x4120
leaq (%rax,%rbp), %r12
incq %r12
addq %rax, %rbp
addq $0x2, %rbp
movq %rbp, %rdi
callq 0x2ce79
movq %rax, %r15
movq 0x18(%r13), %rcx
movq 0x20(%r13), %r8
leaq 0x246d0(%rip), %rdx     # 0x364b7
movq %rax, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2dfae
jmp 0x11e22
movq %rbp, %r12
incq %r12
movq %r12, %rdi
callq 0x2ce79
movq %rax, %r15
movq 0x20(%r13), %rcx
leaq 0x24cbb(%rip), %rdx     # 0x36acd
movq %rax, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2dfae
movq %rbp, %r12
movl $0x4, %edi
movq %r12, %rsi
callq 0x491c
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2ceff
movq %r15, %rdi
movq %r12, %rsi
callq 0x4955
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ceff