LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: trimdead
void
trimdead(Cfg *cfg, Bb *bb)
{
	size_t i;

	if (!bb)
		return;
	for (i = 0; i < bb->nnl; i++) {
		switch (exprop(bb->nl[i])) {
			/* if we're jumping, we can't keep going
			 * within this BB */
		case Ojmp:
		case Ocjmp:
		case Oret:
			bb->nnl = i + 1;
			return;
		case Odead:
			noexit(cfg, bb);
			bb->nnl = i + 1;
			return;
		case Ocall:
			if (isnonretcall(bb->nl[i]->expr.args[0])) {
				noexit(cfg, bb);
				bb->nnl = i + 1;
				return;
			}
			break;
		default:
			/* nothing */
			break;
		}
	}
}

// Assembly:
testq %rsi, %rsi
je 0x2812d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x20(%rsi)
je 0x28124
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x398ba(%rip), %r13     # 0x61968
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1d422
cmpl $0x2e, %eax
jg 0x280f5
cmpl $0x2d, %eax
jne 0x28107
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %r15
movq %r15, %rdi
callq 0x1d422
cmpl $0x33, %eax
jne 0x28107
movq (%r13), %rax
movq 0x38(%r15), %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0x78(%rax)
je 0x28107
jmp 0x28112
leal -0x2f(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2811d
cmpl $0x3b, %eax
je 0x28112
cmpl $0x3e, %eax
je 0x2811d
incq %r12
cmpq 0x20(%rbx), %r12
jb 0x280ae
jmp 0x28124
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28013
incq %r12
movq %r12, 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: trim
void
trim(Cfg *cfg)
{
	Bb *bb;
	size_t i;
	int deleted;

	deleted = 1;
	while (deleted) {
		deleted = 0;
		for (i = 0; i < cfg->nbb; i++) {
			bb = cfg->bb[i];
			if (bb == cfg->start || bb == cfg->end)
				continue;
			trimdead(cfg, bb);
			if (bb && bsisempty(bb->pred)) {
				delete(cfg, bb);
				deleted = 1;
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x2819b
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
cmpq 0x10(%rbx), %r14
je 0x2818a
cmpq 0x18(%rbx), %r14
je 0x2818a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28081
testq %r14, %r14
je 0x2818a
movq 0x28(%r14), %rdi
callq 0x2d604
testl %eax, %eax
je 0x2818a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27ea0
movl $0x1, %r12d
incq %r15
movq 0x20(%rbx), %rax
cmpq %rax, %r15
jb 0x28148
testl %r12d, %r12d
jne 0x2813d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: mkbb
static Bb *
mkbb(Cfg *cfg)
{
	Bb *bb;

	bb = zalloc(sizeof(Bb));
	bb->id = cfg->nextbbid++;
	bb->pred = mkbs();
	bb->succ = mkbs();
	lappend(&cfg->bb, &cfg->nbb, bb);
	return bb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2ce48
movq %rax, %r14
movl 0x28(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%rbx)
movl %eax, (%r14)
callq 0x2d13c
movq %rax, 0x28(%r14)
callq 0x2d13c
movq %rax, 0x30(%r14)
leaq 0x8(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ceff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: addnode
static int
addnode(Cfg *cfg, Bb *bb, Node *n)
{
	switch (exprop(n)) {
	case Ojmp:
	case Ocjmp:
	case Oret:
		lappend(&bb->nl, &bb->nnl, n);
		lappend(&cfg->fixjmp, &cfg->nfixjmp, n);
		lappend(&cfg->fixblk, &cfg->nfixblk, bb);
		return 1;
	case Ocall:
		lappend(&bb->nl, &bb->nnl, n);
		return isnonretcall(n->expr.args[0]);
	case Odead:
		lappend(&bb->nl, &bb->nnl, n);
		return 1;
	default:
		lappend(&bb->nl, &bb->nnl, n);
		break;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1d422
cmpl $0x3a, %eax
jg 0x28619
leal -0x2f(%rax), %ecx
cmpl $0x2, %ecx
jb 0x28623
cmpl $0x2d, %eax
jne 0x28671
leaq 0x18(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ceff
movq 0x50(%r14), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x1d422
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x33, %ecx
jne 0x2866b
leaq 0x39360(%rip), %rax     # 0x61968
movq (%rax), %rax
movq 0x38(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x78(%rax), %eax
jmp 0x2866b
cmpl $0x3b, %eax
je 0x28653
cmpl $0x3e, %eax
jne 0x28671
leaq 0x18(%rbx), %rdi
leaq 0x20(%rbx), %rsi
movq %r14, %rdx
callq 0x2ceff
leaq 0x38(%r15), %rdi
leaq 0x40(%r15), %rsi
movq %r14, %rdx
callq 0x2ceff
leaq 0x48(%r15), %rdi
addq $0x50, %r15
movq %r15, %rsi
movq %rbx, %rdx
jmp 0x28661
leaq 0x18(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ceff
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2ceff
xorl %eax, %eax
jmp 0x2866b
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: dumpcfg
void
dumpcfg(Cfg *cfg, FILE *fd)
{
	size_t i;

	for (i = 0; i < cfg->nbb; i++) {
		if (!cfg->bb[i])
			continue;
		fprintf(fd, "\n");
		dumpbb(cfg->bb[i], fd);
	}
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x286d8
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rcx
cmpq $0x0, (%rcx,%r15,8)
je 0x286cb
movl $0xa, %edi
movq %rbx, %rsi
callq 0x41f0
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x286d9
movq 0x20(%r14), %rax
incq %r15
cmpq %rax, %r15
jb 0x2869f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/cfg.c
// Function: dumpbb
void
dumpbb(Bb *bb, FILE *fd)
{
	size_t i;
	char *sep;

	fprintf(fd, "Bb: %d labels=(", bb->id);
	sep = "";
	for (i = 0; i < bb->nlbls; i++) {;
		fprintf(fd, "%s%s", bb->lbls[i], sep);
		sep = ",";
	}
	fprintf(fd, ")\n");

	/* in edges */
	fprintf(fd, "Pred: ");
	sep = "";
	for (i = 0; i < bsmax(bb->pred); i++) {
		if (bshas(bb->pred, i)) {
			fprintf(fd, "%s%zd", sep, i);
			sep = ",";
		}
	}
	fprintf(fd, "\n");

	/* out edges */
	fprintf(fd, "Succ: ");
	sep = "";
	for (i = 0; i < bsmax(bb->succ); i++) {
		if (bshas(bb->succ, i)) {
			fprintf(fd, "%s%zd", sep, i);
			sep = ",";
		}
	}
	fprintf(fd, "\n");

	for (i = 0; i < bb->nnl; i++)
		dumpn(bb->nl[i], fd);
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x9774(%rip), %rsi      # 0x31e67
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x10(%r14)
je 0x2873d
leaq 0x973f(%rip), %rcx      # 0x31e4a
leaq 0x9431(%rip), %r15      # 0x31b43
leaq 0x1062f(%rip), %r12     # 0x38d48
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r13
movq %r12, %rcx
cmpq 0x10(%r14), %r13
jb 0x2871c
leaq 0xa486(%rip), %rdi      # 0x32bca
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
leaq 0x971a(%rip), %rdi      # 0x31e77
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
movq 0x28(%r14), %rdi
callq 0x2d361
testq %rax, %rax
je 0x287e1
leaq 0x96c6(%rip), %r13      # 0x31e4a
leaq 0x992d(%rip), %r15      # 0x320b8
leaq 0x105b6(%rip), %rbp     # 0x38d48
xorl %r12d, %r12d
movq 0x28(%r14), %rdi
movq (%rdi), %rax
shlq $0x6, %rax
cmpq %r12, %rax
jbe 0x287d4
movq 0x8(%rdi), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jae 0x287d4
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4240
movq 0x28(%r14), %rdi
movq %rbp, %r13
incq %r12
callq 0x2d361
cmpq %rax, %r12
jb 0x28795
movl $0xa, %edi
movq %rbx, %rsi
callq 0x41f0
leaq 0x9689(%rip), %rdi      # 0x31e7e
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
movq 0x30(%r14), %rdi
callq 0x2d361
testq %rax, %rax
je 0x28879
leaq 0x962e(%rip), %r13      # 0x31e4a
leaq 0x9895(%rip), %r15      # 0x320b8
leaq 0x1051e(%rip), %rbp     # 0x38d48
xorl %r12d, %r12d
movq 0x30(%r14), %rdi
movq (%rdi), %rax
shlq $0x6, %rax
cmpq %r12, %rax
jbe 0x2886c
movq 0x8(%rdi), %rax
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jae 0x2886c
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x4240
movq 0x30(%r14), %rdi
movq %rbp, %r13
incq %r12
callq 0x2d361
cmpq %rax, %r12
jb 0x2882d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x41f0
cmpq $0x0, 0x20(%r14)
je 0x288a9
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x13806
incq %r15
cmpq 0x20(%r14), %r15
jb 0x28890
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: flattenfn
Node *
flattenfn(Node *dcl)
{
	if (ismain(dcl))
		dcl->decl.vis = Vishidden;
	if (dcl->decl.isextern || dcl->decl.isgeneric)
		return dcl;
	if (isconstfn(dcl)) {
		dcl = flatteninit(dcl);
		//lappend(fn, nfn, f);
	}

	//lappend(fn, nfn, f);
	return dcl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq $0x0, 0x18(%rax)
jne 0x288f5
movq 0x20(%rax), %rdi
leaq 0x923d(%rip), %rsi      # 0x31b25
callq 0x4230
testl %eax, %eax
jne 0x288f5
movb $0x2, 0x70(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x2898a
cmpb $0x0, 0x73(%rbx)
jne 0x2898a
movq %rbx, %rdi
callq 0x28999
testl %eax, %eax
je 0x2898a
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq $0x0, 0x60(%r14)
movq 0x30(%rbx), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %r12
movq 0x20(%r12), %rax
movq 0x40(%r12), %r15
movq %rax, 0x50(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x28a49
movq 0x18(%r15), %rsi
movq (%r12), %rdi
callq 0x1db37
movq 0x8(%r14), %rcx
movq %rcx, 0x28(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x40(%r12)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: isconstfn
int
isconstfn(Node *n)
{
	Node *d, *e;
	Type *t;

	if (n->type == Nexpr) {
		if (exprop(n) != Ovar)
			return 0;
		d = decls[n->expr.did];
	} else {
		d = n;
	}
	t = tybase(decltype(d));
	if (!d || !d->decl.isconst || d->decl.isgeneric)
		return 0;
	if (!d->decl.isglobl && !d->decl.isextern)
		return 0;
	if (t->type != Tyfunc && t->type != Tycode)
		return 0;
	e = d->decl.init;
	if (e && (exprop(e) != Olit || e->expr.args[0]->lit.littype != Lfunc))
		return 0;
	if (!e && !d->decl.isextern && !d->decl.isimport)
		return 0;
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0x8, 0x8(%rdi)
jne 0x289c8
movq %r14, %rdi
callq 0x1d422
xorl %ebx, %ebx
cmpl $0x33, %eax
jne 0x289ed
leaq 0x38fab(%rip), %rax     # 0x61968
movq (%rax), %rax
movq 0x38(%r14), %rcx
movq (%rax,%rcx,8), %r14
movq %r14, %rdi
callq 0x1e31c
movq %rax, %rdi
callq 0x227ac
xorl %ebx, %ebx
testq %r14, %r14
je 0x289ed
cmpb $0x0, 0x72(%r14)
je 0x289ed
cmpb $0x0, 0x73(%r14)
je 0x289f5
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0x71(%r14)
jne 0x28a03
cmpb $0x0, 0x74(%r14)
je 0x289ed
movl (%rax), %eax
cmpl $0x1e, %eax
je 0x28a0f
cmpl $0x13, %eax
jne 0x289ed
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x28a34
movq %r15, %rdi
callq 0x1d422
cmpl $0x35, %eax
jne 0x289ed
movq 0x50(%r15), %rax
movq (%rax), %rax
cmpl $0x5, 0x18(%rax)
jne 0x289ed
jmp 0x28a42
cmpb $0x0, 0x74(%r14)
jne 0x28a42
cmpb $0x0, 0x77(%r14)
je 0x289ed
movl $0x1, %ebx
jmp 0x289ed
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: flattenif
static void
flattenif(Flattenctx *s, Node *n, Node *exit)
{
	Node *l1, *l2, *l3;
	Node *cond, *iftrue, *iffalse, *t;

	l1 = genlbl(n->loc);
	l2 = genlbl(n->loc);
	if (exit)
		l3 = exit;
	else
		l3 = genlbl(n->loc);

	cond = rval(s, n->ifstmt.cond);
	iftrue = n->ifstmt.iftrue;
	iffalse = n->ifstmt.iffalse;
	if (s->incqueue) {
		t = temp(s, cond);
		flatten(s, asn(t, cond));
		draininc(s);
		cond = t;
	}

	flattencond(s, cond, l1, l2);
	flatten(s, l1);
	draininc(s);
	/* goto test */
	flatten(s, iftrue);
	jmp(s, l3);
	flatten(s, l2);
	draininc(s);
	/* because lots of bunched up end labels are ugly,
	 * coalesce them by handling 'elif'-like construct
	 * separately */
	if (iffalse && iffalse->type == Nifstmt) {
		flattenif(s, iffalse, exit);
	} else {
		flatten(s, iffalse);
		jmp(s, l3);
	}

	if (!exit)
		flatten(s, l3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1de03
movq %rax, %r13
movq (%r15), %rdi
callq 0x1de03
movq %rax, %r12
movq (%r15), %rdi
callq 0x1de03
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x2925b
movq %rax, %rbp
movq 0x20(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%r15), %r15
cmpq $0x0, 0x20(%rbx)
je 0x29181
movq %rbp, %rdi
callq 0x29fee
movq %r14, 0x8(%rsp)
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x29de7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28a49
movq %rbx, %rdi
callq 0x29b32
movq %r14, %rbp
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x29a89
movq %rbx, %rdi
movq %r13, %rsi
callq 0x28a49
movq %rbx, %rdi
callq 0x29b32
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x28a49
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299a5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x28a49
movq %rbx, %rdi
callq 0x29b32
testq %r15, %r15
je 0x291f4
cmpl $0x2, 0x8(%r15)
jne 0x291e9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x290f3
jmp 0x291ff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28a49
movq %rbx, %rdi
movq %r14, %rsi
callq 0x299a5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28a49
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: exitscope
static int
exitscope(Flattenctx *s, Stab *stop, Srcloc loc, Exit x)
{
	Node *exit;
	Stab *st;

	for (st = s->curst;; st = st->super) {
		exit = st->exit[x];
		if (st->ndisposed[x] < st->nautotmp) {
			st->exit[x] = genlbl(loc);
			flatten(s, st->exit[x]);
			dispose(s, st, st->ndisposed[x]);
			st->ndisposed[x] = st->nautotmp;
		}
		if (exit) {
			jmp(s, exit);
			return 0;
		}
		if ((!stop && st->isfunc) || st == stop) {
			return 1;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rdi), %r12
movl %ecx, %ebp
movq (%r12), %r12
movq 0x60(%r12,%rbp,8), %r13
movq 0x78(%r12,%rbp,8), %rax
cmpq 0x58(%r12), %rax
jae 0x298c0
movq %r14, %rdi
callq 0x1de03
movq %rax, 0x60(%r12,%rbp,8)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28a49
movq 0x78(%r12,%rbp,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x298fc
movq 0x58(%r12), %rax
movq %rax, 0x78(%r12,%rbp,8)
testq %r13, %r13
jne 0x298e0
testq %r15, %r15
je 0x298d1
cmpq %r15, %r12
jne 0x29879
jmp 0x298d9
cmpb $0x0, 0x10(%r12)
je 0x29879
movl $0x1, %eax
jmp 0x298ed
movq %rbx, %rdi
movq %r13, %rsi
callq 0x299a5
xorl %eax, %eax
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/mi/flatten.c
// Function: dispose
static void
dispose(Flattenctx *s, Stab *st, size_t n)
{
	Node *e, *call, *func;
	Trait *tr;
	Type *ty;
	size_t i;

	tr = traittab[Tcdisp];
	/* dispose in reverse order of appearance */
	for (i = st->nautotmp; i-- > n;) {
		e = st->autotmp[i];
		ty = exprtype(e);
		func = traitfn(Zloc, tr, "__dispose__", ty);
		call = mkexpr(Zloc, Ocall, func, e, NULL);
		call->expr.type = mktype(Zloc, Tyvoid);
		flatten(s, call);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x58(%rsi), %r13
cmpq %rdx, %r13
jbe 0x29996
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x388d4(%rip), %rax     # 0x621f8
movq (%rax), %rax
movq 0x38(%rax), %r12
movq 0x50(%r14), %rax
movq -0x8(%rax,%r13,8), %rbp
decq %r13
movq %rbp, %rdi
callq 0x1e384
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rsi
leaq 0xe4d8(%rip), %rdx      # 0x37e26
movq %rax, %rcx
callq 0x299e6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2d, %esi
movq %rax, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %rbp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x2289d
movq %rax, 0x20(%rbp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x28a49
cmpq %rbx, %r13
ja 0x2992b
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/mi/flatten.c
// Function: traitfn
static Node *
traitfn(Srcloc loc, Trait *tr, char *fn, Type *ty)
{
	Node *proto, *dcl, *var;
	char *name;
	size_t i;

	for (i = 0; i < tr->nproto; i++) {
		name = declname(tr->proto[i]);
		if (!strcmp(fn, name)) {
			proto = tr->proto[i];
			dcl = htget(proto->decl.impls, ty);
			var = mkexpr(loc, Ovar, dcl->decl.name, NULL);
			var->expr.type = dcl->decl.type;
			var->expr.did = dcl->decl.did;
			return var;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x38(%rsi)
je 0x29a32
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x30(%r12), %rax
movq (%rax,%rbp,8), %rdi
callq 0x1e2ed
movq %r13, %rdi
movq %rax, %rsi
callq 0x4230
testl %eax, %eax
je 0x29a37
incq %rbp
cmpq 0x38(%r12), %rbp
jb 0x29a09
jmp 0x29a77
xorl %r14d, %r14d
jmp 0x29a77
movq 0x30(%r12), %rax
movq (%rax,%rbp,8), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0x2d8fa
movq %rax, %r15
movq 0x20(%rax), %rdx
movq %rbx, %rdi
movl $0x33, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r14
movq 0x28(%r15), %rax
movq %rax, 0x20(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x38(%r14)
movq %r14, %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/mi/flatten.c
// Function: flattencond
static void
flattencond(Flattenctx *s, Node *n, Node *ltrue, Node *lfalse)
{
	Node **args;
	Node *v, *lnext;

	args = n->expr.args;
	switch (exprop(n)) {
	case Oland:
		lnext = genlbl(n->loc);
		flattencond(s, args[0], lnext, lfalse);
		append(s, lnext);
		flattencond(s, args[1], ltrue, lfalse);
		break;
	case Olor:
		lnext = genlbl(n->loc);
		flattencond(s, args[0], ltrue, lnext);
		append(s, lnext);
		flattencond(s, args[1], ltrue, lfalse);
		break;
	case Olnot:
		flattencond(s, args[0], lfalse, ltrue);
		break;
	default:
		v = rval(s, n);
		cjmp(s, v, ltrue, lfalse);
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %r15
movq 0x50(%r12), %r13
movq %r12, %rdi
callq 0x1d422
cmpl $0x14, %eax
je 0x29ad0
cmpl $0x15, %eax
jne 0x29aff
movq (%r12), %rdi
callq 0x1de03
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
jmp 0x29ae9
movq (%r12), %rdi
callq 0x1de03
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x29a89
movq %r14, %rdi
movq %r12, %rsi
callq 0x29218
movq 0x8(%r13), %r12
jmp 0x29a9e
cmpl $0x16, %eax
jne 0x29b10
movq (%r13), %r12
movq %rbx, %rdx
movq %r15, %rbx
jmp 0x29a9b
movq %r14, %rdi
movq %r12, %rsi
callq 0x2925b
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29b75
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: draininc
static void
draininc(Flattenctx *fc)
{
	size_t i;

	for (i = 0; i < fc->nqueue; i++)
		append(fc, fc->incqueue[i]);
	lfree(&fc->incqueue, &fc->nqueue);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
cmpq $0x0, 0x28(%rdi)
je 0x29b61
xorl %r15d, %r15d
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x29218
incq %r15
cmpq 0x28(%r14), %r15
jb 0x29b48
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2d0c7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: asn
static Node *
asn(Node *a, Node *b)
{
	Node *n;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29e42
movq %rsi, %r14
testq %rsi, %rsi
je 0x29e42
movq %rdi, %rbx
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
cmpl $0x1, (%rax)
je 0x29e37
movq (%rbx), %rdi
movl $0x1d, %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 0x8563(%rip), %rdi      # 0x323ac
leaq 0xeba9(%rip), %rsi      # 0x389f9
leaq 0xebd2(%rip), %rcx      # 0x38a29
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: addk
static Node *
addk(Node *n, uvlong v)
{
	Node *k;

	k = mkintlit(n->loc, v);
	k->expr.type = exprtype(n);
	return add(n, k);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x1d57a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e384
movq %rax, 0x20(%r14)
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)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: seqlen
static Node *
seqlen(Flattenctx *s, Node *n, Type *ty)
{
	Node *r;

	if (!ty)
		ty = n->expr.type;
	if (exprtype(n)->type == Tyarray) {
		r = mkexpr(n->loc, Osllen, rval(s, n), NULL);
		r->expr.type = ty;
	} else if (exprtype(n)->type == Tyslice) {
		r = mkexpr(n->loc, Osllen, rval(s, n), NULL);
		r->expr.type = ty;
	} else {
		die("invalid seq type for len");
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
jne 0x29ec3
movq 0x20(%r14), %rbx
movq %r14, %rdi
callq 0x1e384
cmpl $0x15, (%rax)
je 0x29edd
movq %r14, %rdi
callq 0x1e384
cmpl $0x14, (%rax)
jne 0x29f06
movq %r15, %rdi
movq %r14, %rsi
callq 0x2925b
movq (%r14), %rdi
movl $0x41, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xeb36(%rip), %rdi      # 0x38a43
xorl %eax, %eax
callq 0x13844
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: flattenloopmatch
static void
flattenloopmatch(Flattenctx *s, Node *pat, Node *val, Node *ltrue, Node *lfalse)
{
	Node **cap, **out, *lload;
	size_t i, ncap, nout;

	/* pattern match */
	lload = genlbl(pat->loc);
	out = NULL;
	nout = 0;
	cap = NULL;
	ncap = 0;
	genonematch(pat, val, lload, lfalse, &out, &nout, &cap, &ncap);
	for (i = 0; i < nout; i++)
		flatten(s, out[i]);
	flatten(s, lload);
	for (i = 0; i < ncap; i++)
		flatten(s, cap[i]);
	jmp(s, ltrue);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1de03
movq %rax, %r15
xorl %r12d, %r12d
leaq 0x28(%rsp), %r8
movq %r12, (%r8)
leaq 0x20(%rsp), %rbx
movq %r12, (%rbx)
leaq 0x30(%rsp), %rax
movq %r12, (%rax)
leaq 0x8(%rsp), %r10
movq %r12, (%r10)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %r9
pushq %r10
pushq %rax
callq 0x2bc62
addq $0x10, %rsp
cmpq %r12, (%rbx)
je 0x29fa2
xorl %ebx, %ebx
movq 0x28(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x28a49
incq %rbx
cmpq 0x20(%rsp), %rbx
jb 0x29f87
movq %r14, %rdi
movq %r15, %rsi
callq 0x28a49
cmpq $0x0, 0x8(%rsp)
je 0x29fd2
xorl %ebx, %ebx
movq 0x30(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x28a49
incq %rbx
cmpq 0x8(%rsp), %rbx
jb 0x29fb7
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x299a5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: assign
static Node *
assign(Flattenctx *s, Node *lhs, Node *rhs)
{
	Node *r, *t, *e, *u;

	if (exprop(lhs) == Otup) {
		r = destructure(s, lhs, rhs);
	} else if (tybase(exprtype(lhs))->type != Tyvoid) {
		t = lval(s, lhs);
		u = rval(s, rhs);
		e = asn(t, u);
		append(s, e);
		r = t;
	} else {
		r = rval(s, rhs);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1d422
cmpl $0x37, %eax
jne 0x2a053
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a483
movq %r15, %rdi
callq 0x1e384
movq %rax, %rdi
callq 0x227ac
cmpl $0x1, (%rax)
jne 0x2a078
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2925b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a0b0
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2925b
movq %r15, %rdi
movq %rax, %rsi
callq 0x29de7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29218
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: lval
static Node *
lval(Flattenctx *s, Node *n)
{
	Node *r;

	switch (exprop(n)) {
	case Ovar:	r = n;	break;
	case Oidx:	r = rval(s, n);	break;
	case Oderef:	r = rval(s, n);	break;
	case Otupmemb:	r = rval(s, n); break;
	case Omemb:	r = rval(s, n);	break;
	case Ostruct:	r = rval(s, n);	break;

	/* for chaining */
	case Oucon:	r = rval(s, n);	break;
	case Oarr:	r = rval(s, n);	break;
	case Ogap:	r = temp(s, n);	break;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d422
leal -0x28(%rax), %ecx
cmpl $0x11, %ecx
ja 0x2a0ec
leaq 0xe2a7(%rip), %rax      # 0x38378
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2925b
cmpl $0x13, %eax
je 0x2a0da
movq %rbx, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x3629e(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rdx
leaq 0x8529(%rip), %rsi      # 0x32636
movq %rbx, %rdi
xorl %eax, %eax
callq 0x138e7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29fee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: visit
static Node *
visit(Flattenctx *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]);
	if (opispure[exprop(n)]) {
		r = n;
	} else {
		if (exprtype(n)->type == Tyvoid) {
			r = mkexpr(n->loc, Olit, mkvoid(n->loc), NULL);
			r->expr.type = mktype(n->loc, Tyvoid);
			append(s, n);
		} else {
			r = temp(s, n);
			append(s, asn(r, n));
		}
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x40(%rsi)
je 0x2a3fa
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2925b
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x2a3d9
movq %rbx, %rdi
callq 0x1d422
movl %eax, %eax
leaq 0x36595(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
jne 0x2a47a
movq %rbx, %rdi
callq 0x1e384
cmpl $0x1, (%rax)
jne 0x2a456
movq (%rbx), %rdi
callq 0x1e29b
movq (%rbx), %rdi
movl $0x35, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r15
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x2289d
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x2a472
movq %rbx, %rdi
callq 0x29fee
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29de7
movq %r14, %rdi
movq %rax, %rsi
callq 0x29218
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/flatten.c
// Function: destructure
static Node *
destructure(Flattenctx *s, Node *lhs, Node *rhs)
{
	Node *lv, *rv, *idx;
	Node **args;
	size_t i;

	args = lhs->expr.args;
	rhs = rval(s, rhs);
	for (i = 0; i < lhs->expr.nargs; i++) {
		idx = mkintlit(rhs->loc, i);
		idx->expr.type = mktype(rhs->loc, Tyuint64);
		rv = mkexpr(rhs->loc, Otupget, rhs, idx, NULL);
		rv->expr.type = lhs->expr.type;

		if (exprop(args[i]) == Otup) {
			destructure(s, args[i], rv);
		} else {
			lv = lval(s, args[i]);
			append(s, assign(s, lv, rv));
		}
	}
	return rhs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %rbp
movq %rdx, %rsi
callq 0x2925b
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x2a53f
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r12, %rsi
callq 0x1d57a
movq %rax, %r13
movq (%r15), %rdi
movl $0xe, %esi
callq 0x2289d
movq %rax, 0x20(%r13)
movq (%r15), %rdi
movl $0x45, %esi
movq %r15, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d5e2
movq %rax, %r13
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r13)
movq (%rbp,%r12,8), %rdi
callq 0x1d422
movq (%rbp,%r12,8), %rsi
movq %r14, %rdi
cmpl $0x37, %eax
jne 0x2a514
movq %r13, %rdx
callq 0x2a483
jmp 0x2a532
callq 0x2a0b0
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x2a025
movq %r14, %rdi
movq %rax, %rsi
callq 0x29218
incq %r12
cmpq 0x40(%rbx), %r12
jb 0x2a4b1
movq %r15, %rax
addq $0x8, %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/mi/dfcheck.c
// Function: checkpredret
static void
checkpredret(Cfg *cfg, Bb *bb)
{
	Bb *pred;
	Op op;
	size_t i;

	for (i = 0; bsiter(bb->pred, &i); i++) {
		pred = cfg->bb[i];
		if (pred->nnl == 0) {
			checkpredret(cfg, pred);
		} else {
			op = exprop(pred->nl[pred->nnl - 1]);
			if (op != Oret && op != Odead) {
				fatal(pred->nl[pred->nnl-1], "Reaches end of function without return\n");
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0x28(%rbx), %rdi
callq 0x2d2a6
testl %eax, %eax
je 0x2a769
movq %rsp, %r15
movq 0x8(%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %r12
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x2a74a
movq 0x18(%r12), %rcx
movq -0x8(%rcx,%rax,8), %rdi
callq 0x1d422
cmpl $0x2f, %eax
je 0x2a755
cmpl $0x3b, %eax
je 0x2a755
jmp 0x2a775
movq %r14, %rdi
movq %r12, %rsi
callq 0x2a6f1
incq (%rsp)
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x2d2a6
testl %eax, %eax
jne 0x2a719
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rax
movq 0x20(%r12), %rcx
movq -0x8(%rax,%rcx,8), %rdi
leaq 0xe434(%rip), %rsi      # 0x38bbf
xorl %eax, %eax
callq 0x138e7
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: dtreedumplit
void
dtreedumplit(FILE *fd, Dtree *dt, Node *n, size_t depth)
{
	char *s;

	s = lblstr(dt->lbl);
	switch (n->lit.littype) {
	case Lvoid:	findentf(fd, depth, "%s: Lvoid\n");	break;
	case Lchr:	findentf(fd, depth, "%s: Lchr %c\n", s, n->lit.chrval);	break;
	case Lbool:	findentf(fd, depth, "%s: Lbool %s\n", s, n->lit.boolval ? "true" : "false");	break;
	case Lint:	findentf(fd, depth, "%s: Lint %llu\n", s, n->lit.intval);	break;
	case Lflt:	findentf(fd, depth, "%s: Lflt %lf\n", s, n->lit.fltval);	break;
	case Lstr:	findentf(fd, depth, "%s: Lstr %.*s\n", s, (int)n->lit.strval.len, n->lit.strval.buf);	break;
	case Llbl:	findentf(fd, depth, "%s: Llbl %s\n", s, n->lit.lblval);	break;
	case Lfunc:	findentf(fd, depth, "%s: Lfunc\n");	break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rdi
callq 0x1e5ac
movl 0x18(%r15), %ecx
cmpq $0x7, %rcx
ja 0x2aaad
leaq 0xe230(%rip), %rdx      # 0x38c04
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x30(%r15), %r8d
leaq 0xe2df(%rip), %rdx      # 0x38cc7
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e308
movl 0x30(%r15), %r8d
movq 0x38(%r15), %r9
leaq 0xe2f4(%rip), %rdx      # 0x38cff
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e308
movq 0x30(%r15), %r8
leaq 0xe2b8(%rip), %rdx      # 0x38ce2
jmp 0x2aa99
movsd 0x30(%r15), %xmm0
leaq 0xe2b8(%rip), %rdx      # 0x38cf1
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2e308
leaq 0xe268(%rip), %rdx      # 0x38cbc
jmp 0x2aa7d
cmpl $0x0, 0x30(%r15)
leaq 0x82df(%rip), %rcx      # 0x32d41
leaq 0x82d3(%rip), %r8       # 0x32d3c
cmoveq %rcx, %r8
leaq 0xe260(%rip), %rdx      # 0x38cd4
jmp 0x2aa99
leaq 0xe29e(%rip), %rdx      # 0x38d1b
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e308
movq 0x30(%r15), %r8
leaq 0xe275(%rip), %rdx      # 0x38d0e
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e308
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: dtreedumpnode
void
dtreedumpnode(FILE *fd, Dtree *dt, size_t depth)
{
	size_t i;

	if (dt->accept)
		findentf(fd, depth, "%s: accept\n", lblstr(dt->lbl));

	for (i = 0; i < dt->nnext; i++) {
		dtreedumplit(fd, dt, dt->pat[i]->expr.args[0], depth);
		dtreedumpnode(fd, dt->next[i], depth + 1);
	}
	if (dt->any) {
		findentf(fd, depth, "%s: wildcard\n", lblstr(dt->lbl));
		dtreedumpnode(fd, dt->any, depth + 1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe264(%rip), %r12      # 0x38d32
cmpb $0x0, 0x28(%r14)
je 0x2aaf4
movq 0x10(%r14), %rdi
callq 0x1e5ac
movq %r15, %rdi
movl %ebx, %esi
leaq 0xe23c(%rip), %rdx      # 0x38d26
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e308
cmpq $0x0, 0x48(%r14)
je 0x2ab3b
leaq 0x1(%rbx), %rbp
xorl %r13d, %r13d
movq 0x30(%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2a9a8
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x2aab3
incq %r13
cmpq 0x48(%r14), %r13
jb 0x2ab02
cmpq $0x0, 0x50(%r14)
je 0x2ab69
movq 0x10(%r14), %rdi
callq 0x1e5ac
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e308
movq 0x50(%r14), %r14
incq %rbx
jmp 0x2aace
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/mi/match.c
// Function: pathfmt
char *
pathfmt(Path *p)
{
	size_t i, sz, n;
	char *buf;

	sz = p->len*3+1;
	buf = zalloc(sz);
	n = 0;
	for (i = 0; i < p->len; i++) {
		n += snprintf(&buf[n], sz-n, "%02x,", p->p[i]);
	}
	buf[n-1] = '\0';
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rax,%rax,2), %r15
incq %r15
movq %r15, %rdi
callq 0x2ce48
movq %rax, %rbx
cmpq $0x0, (%r14)
je 0x2abde
leaq 0xe191(%rip), %r12      # 0x38d40
xorl %ebp, %ebp
xorl %r13d, %r13d
leaq (%rbx,%r13), %rdi
movq %r15, %rsi
subq %r13, %rsi
movq 0x8(%r14), %rax
movl (%rax,%rbp,4), %ecx
movq %r12, %rdx
xorl %eax, %eax
callq 0x4150
cltq
addq %rax, %r13
incq %rbp
cmpq (%r14), %rbp
jb 0x2abb4
jmp 0x2abe1
xorl %r13d, %r13d
movb $0x0, -0x1(%rbx,%r13)
movq %rbx, %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/mi/match.c
// Function: pathdump
void
pathdump(Path *p, FILE *out)
{
	size_t i;
	for (i = 0; i < p->len; i++) {
		fprintf(out, "%x,", p->p[i]);
	}
	fprintf(out, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, (%rdi)
je 0x2ac34
movq %rdi, %r14
leaq 0xe132(%rip), %r15      # 0x38d46
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r12
cmpq (%r14), %r12
jb 0x2ac17
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: genfrontier
static void
genfrontier(int i, Node *val, Node *pat, Node *lbl, Frontier ***frontier, size_t *nfrontier)
{
	Frontier *fs;

	fs = mkfrontier(i, lbl);
	addrec(fs, pat, val, mkpath(NULL, 0));
	while (fs != NULL) {
		lappend(frontier, nfrontier, fs);
		fs = fs->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rcx, %rsi
callq 0x2beb6
movq %rax, %r15
movl $0x10, %edi
callq 0x2ce48
movq %rax, %rbp
movl $0x10, %edi
callq 0x2ce48
movq %rax, 0x8(%rbp)
movl $0x0, (%rax)
movq $0x1, (%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x2bf22
testq %r15, %r15
je 0x2b164
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2ceff
movq 0x40(%r15), %r15
jmp 0x2b14b
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/mi/match.c
// Function: verifymatch
static int
verifymatch(Dtree *t)
{
	size_t i;
	int ret;

	if (t->accept)
		return 1;

	ret = 0;
	if (t->nnext == t->nconstructors || t->any)
		ret = 1;
	for (i = 0; i < t->nnext; i++)
		if (!verifymatch(t->next[i]))
			ret = 0;
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpb $0x0, 0x28(%rdi)
jne 0x2b8a1
movq 0x48(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x2b87f
cmpq $0x0, 0x50(%rdi)
jne 0x2b87f
xorl %ebx, %ebx
testq %r14, %r14
je 0x2b8a1
movq 0x40(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x2b859
testl %eax, %eax
cmovel %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x2b88b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: refsum
static size_t
refsum(Dtree *dt)
{
	size_t i;
	size_t sum;

	if (dt == NULL)
		return 0;

	dt->emitted = 1;

	/* NOTE
	 * MATCH nodes are always pre-allocated and shared,
	 * so counted as 1 for the size measurement.
	 */
	if (dt->accept)
		return 1;

	sum = 0;
	for (i = 0; i < dt->nnext; i++)
		if (!dt->next[i]->emitted)
			sum += refsum(dt->next[i]);
	if (dt->any && !dt->any->emitted)
		sum += refsum(dt->any);

	return dt->refcnt + sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2b91a
movq %rdi, %rbx
movb $0x1, 0x29(%rdi)
movl $0x1, %r14d
cmpb $0x0, 0x28(%rdi)
jne 0x2b91d
movq 0x48(%rbx), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x2b8fd
xorl %r15d, %r15d
movq 0x40(%rbx), %rcx
movq (%rcx,%r15,8), %rdi
cmpb $0x0, 0x29(%rdi)
jne 0x2b8f5
callq 0x2b8af
addq %rax, %r14
movq 0x48(%rbx), %rax
incq %r15
cmpq %rax, %r15
jb 0x2b8db
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2b914
cmpb $0x0, 0x29(%rdi)
jne 0x2b914
callq 0x2b8af
addq %rax, %r14
addq 0x68(%rbx), %r14
jmp 0x2b91d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: dtheight
static size_t
dtheight(Dtree *dt)
{
	size_t i, h, m;

	if (dt == NULL)
		return 0;
	if (dt->accept)
		return 0;

	m = 0;
	for (i = 0; i < dt->nnext; i++) {
		h = dtheight(dt->next[i]);
		if (h > m)
			m = h;
	}
	h = dtheight(dt->any);
	if (h > m)
		m = h;
	return m+1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2b93d
movq %rdi, %r14
cmpb $0x0, 0x28(%rdi)
je 0x2b941
xorl %ebx, %ebx
jmp 0x2b982
movq 0x48(%r14), %r15
testq %r15, %r15
je 0x2b96d
movq 0x40(%r14), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
callq 0x2b926
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0x2b953
jmp 0x2b96f
xorl %ebx, %ebx
movq 0x50(%r14), %rdi
callq 0x2b926
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: clearemit
static void
clearemit(Dtree *dt)
{
	size_t i;

	if (dt == NULL)
		return;
	for (i = 0; i < dt->nnext; i++)
		clearemit(dt->next[i]);
	clearemit(dt->any);
	dt->emitted = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2b9cf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x2b9bb
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2b98f
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x2b9a5
movq 0x50(%rbx), %rdi
callq 0x2b98f
movb $0x0, 0x29(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: genonematch
void
genonematch(Node *pat, Node *val, Node *iftrue, Node *iffalse, Node ***out, size_t *nout, Node ***cap, size_t *ncap)
{
	Frontier **frontier;
	size_t nfrontier;
	Dtree *root;

	ndtree = 0;
	frontier = NULL;
	nfrontier = 0;
	genfrontier(0, val, pat, iftrue, &frontier, &nfrontier);
	lcat(cap, ncap, frontier[0]->cap, frontier[0]->ncap);
	genfrontier(1, val, mkexpr(iffalse->loc, Ogap, NULL), iffalse, &frontier, &nfrontier);
	root = compile(frontier, nfrontier);
	genmatchcode(root, out, nout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rcx
movq %rsi, %r12
movq %rdi, %rdx
xorl %eax, %eax
movq %rax, 0x365e5(%rip)     # 0x62270
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
leaq 0x8(%rsp), %rbp
movq %rax, (%rbp)
xorl %edi, %edi
movq %r13, %r8
movq %rbp, %r9
callq 0x2b0ef
movq (%r13), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2d066
movq (%r15), %rdi
movl $0x34, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1d5e2
movl $0x1, %edi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x2b0ef
movq (%r13), %rdi
movq (%rbp), %rsi
callq 0x2b173
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2b9d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: genmatch
void
genmatch(Node *m, Node *val, Node ***out, size_t *nout)
{
	Node **pat, **lbl, *end, *endlbl;
	size_t npat, nlbl, i;
	Dtree *dt;

	lbl = NULL;
	nlbl = 0;

	pat = m->matchstmt.matches;
	npat = m->matchstmt.nmatches;
	for (i = 0; i < npat; i++)
		lappend(&lbl, &nlbl, genlbl(pat[i]->match.block->loc));


	endlbl = genlbl(m->loc);
	dt = gendtree(m, val, lbl, nlbl);
	genmatchcode(dt, out, nout);

	for (i = 0; i < npat; i++) {
		end = mkexpr(pat[i]->loc, Ojmp, endlbl, NULL);
		end->expr.type = mktype(end->loc, Tyvoid);
		lappend(out, nout, lbl[i]);
		lappend(out, nout, pat[i]->match.block);
		lappend(out, nout, end);
	}
	lappend(out, nout, endlbl);

	if (debugopt['m']) {
		dtreedump(stdout, dt);
		for (i = 0; i < *nout; i++)
			dumpn((*out)[i], stdout);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movq 0x20(%rdi), %r15
movq %rdi, %r12
movq 0x28(%rdi), %r14
testq %r15, %r15
je 0x2bd83
xorl %r13d, %r13d
leaq 0x30(%rsp), %rbp
movq (%r14,%r13,8), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x1de03
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2ceff
incq %r13
cmpq %r13, %r15
jne 0x2bd5b
movq (%r12), %rdi
callq 0x1de03
movq %rax, %r13
movq 0x10(%rsp), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x2ac4c
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %r12
movq %r12, %rdx
callq 0x2b9d0
testq %r15, %r15
movq %rbx, 0x8(%rsp)
je 0x2be4d
xorl %ebp, %ebp
movq %r15, 0x28(%rsp)
movq (%r14,%rbp,8), %rax
movq (%rax), %rdi
movl $0x30, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d5e2
movq %r13, %r15
movq %rax, %r13
movq (%rax), %rdi
movl $0x1, %esi
callq 0x2289d
movq %rax, 0x20(%r13)
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rdx
movq %r12, %rbx
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2ceff
movq (%r14,%rbp,8), %rax
movq 0x20(%rax), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2ceff
movq %r12, %rdi
movq %rbx, %r12
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %r13
movq 0x28(%rsp), %r15
callq 0x2ceff
incq %rbp
cmpq %rbp, %r15
jne 0x2bdce
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2ceff
leaq 0x35379(%rip), %rax     # 0x611e0
cmpb $0x0, 0x6d(%rax)
je 0x2bea7
movq %r12, %r14
movq 0x18159(%rip), %r15     # 0x43fd0
movq (%r15), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x2aab3
cmpq $0x0, (%r12)
je 0x2bea7
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%r15), %rsi
callq 0x13806
incq %r12
cmpq (%r14), %r12
jb 0x2be90
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: mkfrontier
static Frontier *
mkfrontier(int i, Node *lbl)
{
	Frontier *fs;

	fs = zalloc(sizeof(Frontier));
	fs->i = i;
	fs->lbl = lbl;
	fs->final = mkdtree(lbl->loc, lbl);
	fs->final->accept = 1;
	return fs;;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0x48, %edi
callq 0x2ce48
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq (%rbx), %r12
movl $0x70, %edi
callq 0x2ce48
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r12, 0x4(%rax)
leaq 0x3637b(%rip), %rsi     # 0x62270
movl 0x36375(%rip), %eax     # 0x62270
movl %eax, (%r15)
leaq 0x36373(%rip), %rdi     # 0x62278
movq %r15, %rdx
callq 0x2ceff
movq %r15, 0x30(%r14)
movb $0x1, 0x28(%r15)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: mkpath
static Path*
mkpath(Path *p, int i)
{
	Path *newp;

	newp = zalloc(sizeof(Path));
	if (p) {
		newp->p = zalloc(sizeof(newp->p[0])*(p->len+1));
		memcpy(newp->p, p->p, sizeof(newp->p[0])*p->len);
		newp->p[p->len] = i;
		newp->len = p->len+1;
	} else {
		newp->p = zalloc(sizeof(int)*4);
		newp->p[0] = 0;
		newp->len = 1;
	}
	assert(newp->p != 0);
	return newp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x10, %edi
callq 0x2ce48
movq %rax, %rbx
testq %r14, %r14
je 0x2c5f3
movq (%r14), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x2ce48
movq %rax, 0x8(%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
shlq $0x2, %rdx
movq %rax, %rdi
callq 0x4270
movq 0x8(%rbx), %rcx
movq (%r14), %rax
movl %ebp, (%rcx,%rax,4)
incq %rax
jmp 0x2c60c
movl $0x10, %edi
callq 0x2ce48
movq %rax, 0x8(%rbx)
movl $0x0, (%rax)
movl $0x1, %eax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: mkslot
static Slot *
mkslot(Path *path, Node *pat, Node *val)
{
	Slot *s;
	s = zalloc(sizeof(Slot));
	s->path = path;
	s->pat = pat;
	s->load = val;
	assert(path != (void *)1);
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x2ce48
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
cmpq $0x1, %r15
je 0x2c646
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc8b1(%rip), %rdi      # 0x38efe
leaq 0xc7ed(%rip), %rsi      # 0x38e41
leaq 0xc8b5(%rip), %rcx      # 0x38f10
movl $0x46, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O3/oridb[P]mc/mi/match.c
// Function: arrayelt
static Node *
arrayelt(Node *n, size_t i)
{
	Node *idx, *elt;

	idx = mkintlit(n->loc, i);
	idx->expr.type = mktype(n->loc, Tyuint64);
	elt = mkexpr(n->loc, Oidx, n, idx, NULL);
	elt->expr.type = tybase(exprtype(n))->sub[0];
	return elt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1d57a
movq %rax, %r14
movq (%rbx), %rdi
movl $0xe, %esi
callq 0x2289d
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
movl $0x28, %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, %rdi
callq 0x227ac
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq