LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x9272(%rip), %rsi      # 0x31e57
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4240
cmpq $0x0, 0x10(%r14)
je 0x28c2f
leaq 0x923d(%rip), %rcx      # 0x31e3a
leaq 0x8f2f(%rip), %r15      # 0x31b33
leaq 0x1016d(%rip), %r12     # 0x38d78
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 0x28c0e
leaq 0x9f84(%rip), %rdi      # 0x32bba
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
leaq 0x9218(%rip), %rdi      # 0x31e67
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
movq 0x28(%r14), %rdi
callq 0x2d80e
testq %rax, %rax
je 0x28cd3
leaq 0x91c4(%rip), %r12      # 0x31e3a
leaq 0x942b(%rip), %r15      # 0x320a8
leaq 0x100f4(%rip), %rbp     # 0x38d78
xorl %r13d, %r13d
movq 0x28(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %r13, %rcx
jbe 0x28cc2
movq 0x8(%rax), %rax
movq %r13, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r13, %rax
jae 0x28cc2
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4240
movq %rbp, %r12
incq %r13
movq 0x28(%r14), %rdi
callq 0x2d80e
cmpq %rax, %r13
jb 0x28c87
movl $0xa, %edi
movq %rbx, %rsi
callq 0x41f0
leaq 0x9187(%rip), %rdi      # 0x31e6e
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4330
movq 0x30(%r14), %rdi
callq 0x2d80e
testq %rax, %rax
je 0x28d6b
leaq 0x912c(%rip), %r12      # 0x31e3a
leaq 0x9393(%rip), %r15      # 0x320a8
leaq 0x1005c(%rip), %rbp     # 0x38d78
xorl %r13d, %r13d
movq 0x30(%r14), %rax
movq (%rax), %rcx
shlq $0x6, %rcx
cmpq %r13, %rcx
jbe 0x28d5a
movq 0x8(%rax), %rax
movq %r13, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
btq %r13, %rax
jae 0x28d5a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x4240
movq %rbp, %r12
incq %r13
movq 0x30(%r14), %rdi
callq 0x2d80e
cmpq %rax, %r13
jb 0x28d1f
movl $0xa, %edi
movq %rbx, %rsi
callq 0x41f0
cmpq $0x0, 0x20(%r14)
je 0x28d9b
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x139c1
incq %r15
cmpq 0x20(%r14), %r15
jb 0x28d82
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x41f0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x28de9
movq 0x20(%rax), %rdi
leaq 0x8d39(%rip), %rsi      # 0x31b15
callq 0x4230
testl %eax, %eax
jne 0x28de9
movb $0x2, 0x70(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x28e78
cmpb $0x0, 0x73(%rbx)
jne 0x28e78
movq %rbx, %rdi
callq 0x28e87
testl %eax, %eax
je 0x28e78
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), %r15
movq 0x20(%r15), %rax
movq 0x40(%r15), %r12
movq %rax, 0x50(%r14)
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x28f37
movq 0x18(%r12), %rsi
movq (%r15), %rdi
callq 0x1dd87
movq 0x8(%r14), %rcx
movq %rcx, 0x28(%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x40(%r15)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x28eb6
movq %r14, %rdi
callq 0x1d672
xorl %ebx, %ebx
cmpl $0x33, %eax
jne 0x28edb
leaq 0x38abd(%rip), %rax     # 0x61968
movq (%rax), %rax
movq 0x38(%r14), %rcx
movq (%rax,%rcx,8), %r14
movq %r14, %rdi
callq 0x1e56c
movq %rax, %rdi
callq 0x22c44
xorl %ebx, %ebx
testq %r14, %r14
je 0x28edb
cmpb $0x0, 0x72(%r14)
je 0x28edb
cmpb $0x0, 0x73(%r14)
je 0x28ee3
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, 0x71(%r14)
jne 0x28ef1
cmpb $0x0, 0x74(%r14)
je 0x28edb
movl (%rax), %eax
cmpl $0x1e, %eax
je 0x28efd
cmpl $0x13, %eax
jne 0x28edb
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x28f22
movq %r15, %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x28edb
movq 0x50(%r15), %rax
movq (%rax), %rax
cmpl $0x5, 0x18(%rax)
jne 0x28edb
jmp 0x28f30
cmpb $0x0, 0x74(%r14)
jne 0x28f30
cmpb $0x0, 0x77(%r14)
je 0x28edb
movl $0x1, %ebx
jmp 0x28edb
// File: /workspace/github_c_makefile_star2_O1/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 0x1e053
movq %rax, %r13
movq (%r15), %rdi
callq 0x1e053
movq %rax, %r12
movq (%r15), %rdi
callq 0x1e053
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x2974d
movq %rax, %rbp
movq 0x20(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%r15), %r15
cmpq $0x0, 0x20(%rbx)
je 0x29673
movq %rbp, %rdi
callq 0x2a4e0
movq %r14, 0x8(%rsp)
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2a2d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28f37
movq %rbx, %rdi
callq 0x2a026
movq %r14, %rbp
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x29f7d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x28f37
movq %rbx, %rdi
callq 0x2a026
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x28f37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29e99
movq %rbx, %rdi
movq %r12, %rsi
callq 0x28f37
movq %rbx, %rdi
callq 0x2a026
testq %r15, %r15
je 0x296db
cmpl $0x2, 0x8(%r15)
jne 0x296db
movq %rbx, %rdi
movq %r15, %rsi
callq 0x295e5
jmp 0x296f1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28f37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29e99
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28f37
// File: /workspace/github_c_makefile_star2_O1/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 0x29da8
movq %r14, %rdi
callq 0x1e053
movq %rax, 0x60(%r12,%rbp,8)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28f37
movq 0x78(%r12,%rbp,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29df0
movq 0x58(%r12), %rax
movq %rax, 0x78(%r12,%rbp,8)
testq %r13, %r13
jne 0x29dcd
testq %r15, %r15
je 0x29db9
cmpq %r15, %r12
jne 0x29d61
jmp 0x29ddc
movl $0x1, %eax
cmpq %r15, %r12
je 0x29de1
cmpb $0x0, 0x10(%r12)
je 0x29d61
jmp 0x29de1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x29e99
xorl %eax, %eax
jmp 0x29de1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x29e8a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x383e0(%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 0x1e5d4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rsi
leaq 0xe014(%rip), %rdx      # 0x37e56
movq %rax, %rcx
callq 0x29eda
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2d, %esi
movq %rax, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %rbp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x22d38
movq %rax, 0x20(%rbp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x28f37
cmpq %rbx, %r13
ja 0x29e1f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x29f26
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 0x1e53d
movq %r13, %rdi
movq %rax, %rsi
callq 0x4230
testl %eax, %eax
je 0x29f2b
incq %rbp
cmpq 0x38(%r12), %rbp
jb 0x29efd
jmp 0x29f6b
xorl %r14d, %r14d
jmp 0x29f6b
movq 0x30(%r12), %rax
movq (%rax,%rbp,8), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0x2dd9a
movq %rax, %r15
movq 0x20(%rax), %rdx
movq %rbx, %rdi
movl $0x33, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
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_O1/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 0x1d672
cmpl $0x14, %eax
je 0x29fc4
cmpl $0x15, %eax
jne 0x29ff3
movq (%r12), %rdi
callq 0x1e053
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
jmp 0x29fdd
movq (%r12), %rdi
callq 0x1e053
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x29f7d
movq %r14, %rdi
movq %r12, %rsi
callq 0x2970a
movq 0x8(%r13), %r12
jmp 0x29f92
cmpl $0x16, %eax
jne 0x2a004
movq (%r13), %r12
movq %rbx, %rdx
movq %r15, %rbx
jmp 0x29f8f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2974d
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a067
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x2a050
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x2970a
incq %r14
cmpq 0x28(%rbx), %r14
jb 0x2a037
leaq 0x28(%rbx), %rsi
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d5c5
// File: /workspace/github_c_makefile_star2_O1/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 0x2a334
movq %rsi, %r14
testq %rsi, %rsi
je 0x2a334
movq %rdi, %rbx
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
cmpl $0x1, (%rax)
je 0x2a329
movq (%rbx), %rdi
movl $0x1d, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8061(%rip), %rdi      # 0x3239c
leaq 0xe6e7(%rip), %rsi      # 0x38a29
leaq 0xe710(%rip), %rcx      # 0x38a59
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1d7ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
movl $0x2, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a3b5
movq 0x20(%r14), %rbx
movq %r14, %rdi
callq 0x1e5d4
cmpl $0x15, (%rax)
je 0x2a3cf
movq %r14, %rdi
callq 0x1e5d4
cmpl $0x14, (%rax)
jne 0x2a3f8
movq %r15, %rdi
movq %r14, %rsi
callq 0x2974d
movq (%r14), %rdi
movl $0x41, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe674(%rip), %rdi      # 0x38a73
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 0x1e053
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 0x2c15b
addq $0x10, %rsp
cmpq %r12, (%rbx)
je 0x2a494
xorl %ebx, %ebx
movq 0x28(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x28f37
incq %rbx
cmpq 0x20(%rsp), %rbx
jb 0x2a479
movq %r14, %rdi
movq %r15, %rsi
callq 0x28f37
cmpq $0x0, 0x8(%rsp)
je 0x2a4c4
xorl %ebx, %ebx
movq 0x30(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x28f37
incq %rbx
cmpq 0x8(%rsp), %rbx
jb 0x2a4a9
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x29e99
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d672
cmpl $0x37, %eax
jne 0x2a545
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2a983
movq %r15, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
cmpl $0x1, (%rax)
jne 0x2a56a
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2974d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a5a2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2974d
movq %r15, %rdi
movq %rax, %rsi
callq 0x2a2d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2970a
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d672
leal -0x28(%rax), %ecx
cmpl $0x11, %ecx
ja 0x2a5de
leaq 0xdde5(%rip), %rax      # 0x383a8
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2974d
cmpl $0x13, %eax
je 0x2a5cc
movq %rbx, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x35dac(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rdx
leaq 0x8027(%rip), %rsi      # 0x32626
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13aa3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a4e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a8fa
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2974d
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x2a8d9
movq %rbx, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x36095(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
jne 0x2a97a
movq %rbx, %rdi
callq 0x1e5d4
cmpl $0x1, (%rax)
jne 0x2a956
movq (%rbx), %rdi
callq 0x1e4eb
movq (%rbx), %rdi
movl $0x35, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r15
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x22d38
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x2a972
movq %rbx, %rdi
callq 0x2a4e0
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2a2d9
movq %r14, %rdi
movq %rax, %rsi
callq 0x2970a
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2974d
movq %rax, %r15
cmpq $0x0, 0x40(%rbx)
je 0x2aa3f
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r12, %rsi
callq 0x1d7ca
movq %rax, %r13
movq (%r15), %rdi
movl $0xe, %esi
callq 0x22d38
movq %rax, 0x20(%r13)
movq (%r15), %rdi
movl $0x45, %esi
movq %r15, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r13
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r13)
movq (%rbp,%r12,8), %rdi
callq 0x1d672
movq (%rbp,%r12,8), %rsi
movq %r14, %rdi
cmpl $0x37, %eax
jne 0x2aa14
movq %r13, %rdx
callq 0x2a983
jmp 0x2aa32
callq 0x2a5a2
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x2a517
movq %r14, %rdi
movq %rax, %rsi
callq 0x2970a
incq %r12
cmpq 0x40(%rbx), %r12
jb 0x2a9b1
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_O1/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 0x2d753
testl %eax, %eax
je 0x2ac64
movq %rsp, %r15
movq 0x8(%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %r12
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x2ac45
movq 0x18(%r12), %rcx
movq -0x8(%rcx,%rax,8), %rdi
callq 0x1d672
cmpl $0x2f, %eax
je 0x2ac50
cmpl $0x3b, %eax
je 0x2ac50
jmp 0x2ac70
movq %r14, %rdi
movq %r12, %rsi
callq 0x2abec
incq (%rsp)
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x2d753
testl %eax, %eax
jne 0x2ac14
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 0xdf69(%rip), %rsi      # 0x38bef
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 0x1e7fc
movl 0x18(%r15), %ecx
cmpq $0x7, %rcx
ja 0x2af9d
leaq 0xdd70(%rip), %rdx      # 0x38c34
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x30(%r15), %r8d
leaq 0xde1f(%rip), %rdx      # 0x38cf7
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e788
movl 0x30(%r15), %r8d
movq 0x38(%r15), %r9
leaq 0xde34(%rip), %rdx      # 0x38d2f
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e788
movq 0x30(%r15), %r8
leaq 0xddf8(%rip), %rdx      # 0x38d12
jmp 0x2af89
movsd 0x30(%r15), %xmm0
leaq 0xddf8(%rip), %rdx      # 0x38d21
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2e788
leaq 0xdda8(%rip), %rdx      # 0x38cec
jmp 0x2af6d
cmpl $0x0, 0x30(%r15)
leaq 0x7ddf(%rip), %rcx      # 0x32d31
leaq 0x7dd3(%rip), %r8       # 0x32d2c
cmoveq %rcx, %r8
leaq 0xdda0(%rip), %rdx      # 0x38d04
jmp 0x2af89
leaq 0xddde(%rip), %rdx      # 0x38d4b
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e788
movq 0x30(%r15), %r8
leaq 0xddb5(%rip), %rdx      # 0x38d3e
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2e788
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdda4(%rip), %r12      # 0x38d62
cmpb $0x0, 0x28(%r14)
je 0x2afe4
movq 0x10(%r14), %rdi
callq 0x1e7fc
movq %r15, %rdi
movl %ebx, %esi
leaq 0xdd7c(%rip), %rdx      # 0x38d56
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e788
cmpq $0x0, 0x48(%r14)
je 0x2b02b
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 0x2ae98
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x2afa3
incq %r13
cmpq 0x48(%r14), %r13
jb 0x2aff2
cmpq $0x0, 0x50(%r14)
je 0x2b059
movq 0x10(%r14), %rdi
callq 0x1e7fc
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2e788
movq 0x50(%r14), %r14
incq %rbx
jmp 0x2afbe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %rbx
cmpq $0x0, (%r14)
je 0x2b0ce
leaq 0xdcd1(%rip), %r12      # 0x38d70
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 0x2b0a4
jmp 0x2b0d1
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_O1/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 0x2b124
movq %rdi, %r14
leaq 0xdc72(%rip), %r15      # 0x38d76
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 0x2b107
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rcx, %rsi
callq 0x2c3af
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x2caa3
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x2c41b
testq %r15, %r15
je 0x2b61a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2d3ff
movq 0x40(%r15), %r15
jmp 0x2b601
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2bdad
movq 0x48(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x2bd8b
cmpq $0x0, 0x50(%rdi)
jne 0x2bd8b
xorl %ebx, %ebx
testq %r14, %r14
je 0x2bdad
movq 0x40(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x2bd65
testl %eax, %eax
cmovel %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x2bd97
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2be06
movq %rdi, %rbx
movb $0x1, 0x29(%rdi)
movl $0x1, %r14d
cmpb $0x0, 0x28(%rdi)
jne 0x2be29
cmpq $0x0, 0x48(%rbx)
je 0x2be0b
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpb $0x0, 0x29(%rdi)
jne 0x2bdfb
callq 0x2bdbb
addq %rax, %r14
incq %r15
cmpq 0x48(%rbx), %r15
jb 0x2bde5
jmp 0x2be0e
xorl %r14d, %r14d
jmp 0x2be29
xorl %r14d, %r14d
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2be25
cmpb $0x0, 0x29(%rdi)
jne 0x2be25
callq 0x2bdbb
addq %rax, %r14
addq 0x68(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2be49
movq %rdi, %r14
cmpb $0x0, 0x28(%rdi)
je 0x2be4d
xorl %ebx, %ebx
jmp 0x2be8e
movq 0x48(%r14), %r15
testq %r15, %r15
je 0x2be79
movq 0x40(%r14), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
callq 0x2be32
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %r13
cmpq %r13, %r15
jne 0x2be5f
jmp 0x2be7b
xorl %ebx, %ebx
movq 0x50(%r14), %rdi
callq 0x2be32
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_O1/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 0x2bedb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x2bec7
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2be9b
incq %r14
cmpq 0x48(%rbx), %r14
jb 0x2beb1
movq 0x50(%rbx), %rdi
callq 0x2be9b
movb $0x0, 0x29(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x360ec(%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 0x2b5c7
movq (%r13), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2d566
movq (%r15), %rdi
movl $0x34, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1d832
movl $0x1, %edi
movq %r12, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0x2b5c7
movq (%r13), %rdi
movq (%rbp), %rsi
callq 0x2b624
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2bedc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c27c
xorl %r13d, %r13d
leaq 0x30(%rsp), %rbp
movq (%r14,%r13,8), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x1e053
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2d3ff
incq %r13
cmpq %r13, %r15
jne 0x2c254
movq (%r12), %rdi
callq 0x1e053
movq %rax, %r13
movq 0x10(%rsp), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x2b13c
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq 0x20(%rsp), %r12
movq %r12, %rdx
callq 0x2bedc
testq %r15, %r15
movq %rbx, 0x8(%rsp)
je 0x2c346
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 0x1d832
movq %r13, %r15
movq %rax, %r13
movq (%rax), %rdi
movl $0x1, %esi
callq 0x22d38
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 0x2d3ff
movq (%r14,%rbp,8), %rax
movq 0x20(%rax), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2d3ff
movq %r12, %rdi
movq %rbx, %r12
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %r13
movq 0x28(%rsp), %r15
callq 0x2d3ff
incq %rbp
cmpq %rbp, %r15
jne 0x2c2c7
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2d3ff
leaq 0x34e80(%rip), %rax     # 0x611e0
cmpb $0x0, 0x6d(%rax)
je 0x2c3a0
movq %r12, %r14
movq 0x17c60(%rip), %r15     # 0x43fd0
movq (%r15), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x2afa3
cmpq $0x0, (%r12)
je 0x2c3a0
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%r15), %rsi
callq 0x139c1
incq %r12
cmpq (%r14), %r12
jb 0x2c389
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq (%rbx), %r12
movl $0x70, %edi
callq 0x2d348
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r12, 0x4(%rax)
leaq 0x35e82(%rip), %rsi     # 0x62270
movl 0x35e7c(%rip), %eax     # 0x62270
movl %eax, (%r15)
leaq 0x35e7a(%rip), %rdi     # 0x62278
movq %r15, %rdx
callq 0x2d3ff
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_O1/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 0x2d348
movq %rax, %rbx
testq %r14, %r14
je 0x2caf4
movq (%r14), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x2d348
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 0x2cb0d
movl $0x10, %edi
callq 0x2d348
movq %rax, 0x8(%rbx)
movl $0x0, (%rax)
movl $0x1, %eax
movq %rax, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x2cb1f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc43f(%rip), %rdi      # 0x38f65
leaq 0xc344(%rip), %rsi      # 0x38e71
leaq 0xc43e(%rip), %rcx      # 0x38f72
movl $0x144, %edx            # imm = 0x144
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x2d348
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
cmpq $0x1, %r15
je 0x2cb6d
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc3ba(%rip), %rdi      # 0x38f2e
leaq 0xc2f6(%rip), %rsi      # 0x38e71
leaq 0xc3be(%rip), %rcx      # 0x38f40
movl $0x46, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 0x1d7ca
movq %rax, %r14
movq (%rbx), %rdi
movl $0xe, %esi
callq 0x22d38
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
movl $0x28, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/mi/match.c
// Function: pateq
static int
pateq(Node *a, Node *b)
{
	if (exprop(a) != exprop(b))
		return 0;

	switch (exprop(a)) {
	case Olit:
		return liteq(a->expr.args[0], b->expr.args[0]);
	case Ogap:
	case Ovar:
		return 1;
	default:
		die("unreachable");
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d672
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1d672
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %ebp
jne 0x2cc28
movq %r14, %rdi
callq 0x1d672
movl %eax, %ecx
movl $0x1, %eax
leal -0x33(%rcx), %edx
cmpl $0x2, %edx
jae 0x2cc2d
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x35, %ecx
jne 0x2cc49
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1e5fe
leaq 0xc431(%rip), %rdi      # 0x39081
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/mi/match.c
// Function: loadeq
static int
loadeq(Node *a, Node *b)
{
	if (a == b)
		return 1;

	if (exprop(a) != exprop(b))
		return 0;

	switch (exprop(a)) {
	case Outag:
	case Oudata:
	case Oderef:
		return loadeq(a->expr.args[0], b->expr.args[0]);
	case Omemb:
		return loadeq(a->expr.args[0], b->expr.args[0]) && nameeq(a->expr.args[1], b->expr.args[1]);
	case Otupget:
	case Oidx:
		return loadeq(a->expr.args[0], b->expr.args[0]) && liteq(a->expr.args[1]->expr.args[0], b->expr.args[1]->expr.args[0]);
	case Ovar:
		return a == b;
	default:
		die("unreachable");
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpq %rbx, %r14
je 0x2cd31
movq %r14, %rdi
callq 0x1d672
movl %eax, %r15d
movq %rbx, %rdi
callq 0x1d672
cmpl %eax, %r15d
jne 0x2cdc3
movq %r14, %rdi
callq 0x1d672
cmpl $0x32, %eax
jle 0x2cd1c
leal -0x43(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2cd21
jmp 0x2cd77
cmpl $0x13, %eax
jne 0x2cd3b
movq 0x50(%r14), %rax
movq (%rax), %r14
movq 0x50(%rbx), %rax
movq (%rax), %rbx
jmp 0x2cce4
movl $0x1, %ebp
jmp 0x2cdc3
cmpl $0x28, %eax
je 0x2cd81
cmpl $0x2a, %eax
jne 0x2cdd0
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
callq 0x2ccd5
testl %eax, %eax
je 0x2cdc3
movq 0x50(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x1e773
jmp 0x2cdbb
cmpl $0x33, %eax
je 0x2cdc3
cmpl $0x45, %eax
jne 0x2cdd0
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
callq 0x2ccd5
testl %eax, %eax
je 0x2cdc3
movq 0x50(%r14), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x1e5fe
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2aa(%rip), %rdi      # 0x39081
xorl %eax, %eax
callq 0x13a00
nop
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/mi/reaching.c
// Function: assignee
Node *
assignee(Node *n)
{
	Node *a;

	switch (exprop(n)) {
	case Oundef: case Odef:
	case Oset:
	case Oasn: case Oaddeq:
	case Osubeq: case Omuleq:
	case Odiveq: case Omodeq:
	case Oboreq: case Obandeq:
	case Obxoreq: case Obsleq:
	case Obsreq:
		return n->expr.args[0];
		break;
	case Oblit:
	case Oclear:
		a = n->expr.args[0];
		if (exprop(a) != Oaddr)
			break;
		a = a->expr.args[0];
		if (exprop(a) != Ovar)
			break;
		return a;
	default:
		break;
	}
	return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1d672
addl $-0x1d, %eax
cmpl $0x2a, %eax
ja 0x2ce45
movabsq $0x9800007ff, %rcx      # imm = 0x9800007FF
btq %rax, %rcx
jae 0x2ce0d
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rax
popq %rbx
retq
movabsq $0x60000000000, %rcx    # imm = 0x60000000000
btq %rax, %rcx
jae 0x2ce45
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x1d672
cmpl $0x12, %eax
jne 0x2ce45
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x1d672
cmpl $0x33, %eax
je 0x2ce08
xorl %ebx, %ebx
jmp 0x2ce08
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/mi/reaching.c
// Function: bsdump
void
bsdump(Bitset *bs)
{
	size_t i;
	for (i = 0; bsiter(bs, &i); i++)
		printf("%zd ", i);
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
callq 0x2d753
testl %eax, %eax
je 0x2ce99
leaq 0xc277(%rip), %r14      # 0x390e8
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4140
incq 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d753
testl %eax, %eax
jne 0x2ce76
movl $0xa, %edi
callq 0x4050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/mi/reaching.c
// Function: reachingfree
void
reachingfree(Reaching *r)
{
	size_t i;

	for (i = 0; i < r->nbb; i++) {
		bsfree(r->in[i]);
		bsfree(r->out[i]);
	}
	for (i = 0; i < ndecls; i++)
		free(r->defs[i]);
	free(r->in);
	free(r->out);
	free(r->defs);
	free(r->ndefs);
	free(r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x2d2f2
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2d664
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2d664
incq %r14
cmpq 0x20(%rbx), %r14
jb 0x2d2d0
leaq 0x34667(%rip), %r14     # 0x61960
cmpq $0x0, (%r14)
je 0x2d317
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x4040
incq %r15
cmpq (%r14), %r15
jb 0x2d302
movq (%rbx), %rdi
callq 0x4040
movq 0x8(%rbx), %rdi
callq 0x4040
movq 0x10(%rbx), %rdi
callq 0x4040
movq 0x18(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4040
nop