LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1bc4f
movq %rax, %r13
movq (%r15), %rdi
callq 0x1bc4f
movq %rax, %r12
movq (%r15), %rdi
callq 0x1bc4f
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x261a7
movq %rax, %rbp
movq 0x20(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%r15), %r15
cmpq $0x0, 0x20(%rbx)
je 0x260cd
movq %rbp, %rdi
callq 0x26edc
movq %r14, 0x8(%rsp)
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x26cf2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x259b0
movq %rbx, %rdi
callq 0x26a46
movq %r14, %rbp
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2699d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x259b0
movq %rbx, %rdi
callq 0x26a46
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x259b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x268cb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x259b0
movq %rbx, %rdi
callq 0x26a46
testq %r15, %r15
je 0x26135
cmpl $0x2, 0x8(%r15)
jne 0x26135
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2603f
jmp 0x2614b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x259b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x268cb
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x259b0
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x50(%rdi), %r13
movl %ecx, %ebx
movq (%r13), %r13
movq 0x60(%r13,%rbx,8), %rbp
movq 0x78(%r13,%rbx,8), %rax
cmpq 0x58(%r13), %rax
jae 0x267f4
movq %r15, %rdi
callq 0x1bc4f
movq %rax, 0x60(%r13,%rbx,8)
movq %r14, %rdi
movq %rax, %rsi
callq 0x259b0
movq 0x78(%r13,%rbx,8), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2682d
movq 0x58(%r13), %rax
movq %rax, 0x78(%r13,%rbx,8)
testq %rbp, %rbp
jne 0x26811
testq %r12, %r12
je 0x26805
cmpq %r12, %r13
jne 0x267af
jmp 0x2680c
cmpb $0x0, 0x10(%r13)
je 0x267af
pushq $0x1
popq %rax
jmp 0x2681e
movq %r14, %rdi
movq %rbp, %rsi
callq 0x268cb
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_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x389b0(%rip), %rax     # 0x5f1f8
movq (%rax), %rax
movq 0x38(%rax), %r12
movq 0x58(%rsi), %r13
cmpq %rbx, %r13
jbe 0x268bc
movq 0x50(%r14), %rax
movq -0x8(%rax,%r13,8), %rbp
decq %r13
movq %rbp, %rdi
callq 0x1bf90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rsi
leaq 0xd5bb(%rip), %rdx      # 0x33e36
movq %rax, %rcx
callq 0x26908
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
pushq $0x2d
popq %rsi
movq %rax, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %rbp
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
pushq $0x1
popq %rsi
callq 0x1fdc2
movq %rax, 0x20(%rbp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x259b0
jmp 0x26853
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/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
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq 0x38(%r12), %rbp
jae 0x2698b
movq 0x30(%r12), %rax
movq (%rax,%rbp,8), %rdi
callq 0x1befe
movq %r13, %rdi
movq %rax, %rsi
callq 0x4230
testl %eax, %eax
je 0x2694d
incq %rbp
jmp 0x26924
movq 0x30(%r12), %rax
movq (%rax,%rbp,8), %rax
movq 0x48(%rax), %rdi
movq %r15, %rsi
callq 0x2a3e8
movq %rax, %r15
movq 0x20(%rax), %rdx
pushq $0x33
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
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_O2/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 0x1b5e6
cmpl $0x14, %eax
je 0x269e4
cmpl $0x15, %eax
jne 0x26a13
movq (%r12), %rdi
callq 0x1bc4f
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
jmp 0x269fd
movq (%r12), %rdi
callq 0x1bc4f
movq %rax, %r12
movq (%r13), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x2699d
movq %r14, %rdi
movq %r12, %rsi
callq 0x26164
movq 0x8(%r13), %r12
jmp 0x269b2
cmpl $0x16, %eax
jne 0x26a24
movq (%r13), %r12
movq %rbx, %rdx
movq %r15, %rbx
jmp 0x269af
movq %r14, %rdi
movq %r12, %rsi
callq 0x261a7
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26a8c
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
leaq 0x20(%rdi), %r15
xorl %r12d, %r12d
cmpq (%rbx), %r12
jae 0x26a76
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x26164
incq %r12
jmp 0x26a5c
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29cc7
// File: /workspace/github_c_makefile_star2_O2/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 0x26d4b
movq %rsi, %r14
testq %rsi, %rsi
je 0x26d4b
movq %rdi, %rbx
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x1, (%rax)
je 0x26d40
movq (%rbx), %rdi
pushq $0x1d
popq %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x762a(%rip), %rdi      # 0x2e37c
leaq 0xdcc0(%rip), %rsi      # 0x34a19
leaq 0xdce9(%rip), %rcx      # 0x34a49
pushq $0x60
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x1b6fc
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
pushq $0x2
popq %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26dc6
movq 0x20(%r14), %rbx
movq %r14, %rdi
callq 0x1bf90
cmpl $0x15, (%rax)
je 0x26de0
movq %r14, %rdi
callq 0x1bf90
cmpl $0x14, (%rax)
jne 0x26e07
movq %r15, %rdi
movq %r14, %rsi
callq 0x261a7
movq (%r14), %rdi
pushq $0x41
popq %rsi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xdc55(%rip), %rdi      # 0x34a63
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1bc4f
movq %rax, %r15
leaq 0x18(%rsp), %r8
andq $0x0, (%r8)
leaq 0x8(%rsp), %r9
andq $0x0, (%r9)
leaq 0x20(%rsp), %rax
andq $0x0, (%rax)
leaq 0x10(%rsp), %r10
andq $0x0, (%r10)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
pushq %r10
pushq %rax
callq 0x2894c
popq %rax
popq %rcx
xorl %r12d, %r12d
cmpq 0x8(%rsp), %r12
jae 0x26e97
movq 0x18(%rsp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0x259b0
incq %r12
jmp 0x26e7a
movq %r14, %rdi
movq %r15, %rsi
callq 0x259b0
xorl %r15d, %r15d
cmpq 0x10(%rsp), %r15
jae 0x26ec2
movq 0x20(%rsp), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x259b0
incq %r15
jmp 0x26ea5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x268cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5e6
cmpl $0x37, %eax
jne 0x26f3f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x27353
movq %r15, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
cmpl $0x1, (%rax)
jne 0x26f64
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x261a7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26f9c
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x261a7
movq %r15, %rdi
movq %rax, %rsi
callq 0x26cf2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x26164
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5e6
leal -0x28(%rax), %ecx
cmpl $0x11, %ecx
ja 0x26fd8
leaq 0xd3d7(%rip), %rax      # 0x34394
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x261a7
cmpl $0x13, %eax
je 0x26fc6
movq %rbx, %rdi
callq 0x1b5e6
movl %eax, %eax
leaq 0x363b2(%rip), %rcx     # 0x5d3a0
movq (%rcx,%rax,8), %rdx
leaq 0x760d(%rip), %rsi      # 0x2e606
movq %rbx, %rdi
xorl %eax, %eax
callq 0x120fd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26edc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
cmpq 0x40(%rbx), %r15
jae 0x272ce
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x261a7
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x272ab
movq %rbx, %rdi
callq 0x1b5e6
movl %eax, %eax
leaq 0x366c1(%rip), %rcx     # 0x5d9a0
cmpl $0x0, (%rcx,%rax,4)
jne 0x2734a
movq %rbx, %rdi
callq 0x1bf90
cmpl $0x1, (%rax)
jne 0x27326
movq (%rbx), %rdi
callq 0x1beec
movq (%rbx), %rdi
pushq $0x35
popq %rsi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r15
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1fdc2
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x27342
movq %rbx, %rdi
callq 0x26edc
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x26cf2
movq %r14, %rdi
movq %rax, %rsi
callq 0x26164
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r12
movq %rdx, %rsi
callq 0x261a7
movq %rax, %r15
xorl %r13d, %r13d
cmpq 0x40(%rbx), %r13
jae 0x27403
movq (%r15), %rdi
movq %r13, %rsi
callq 0x1b6fc
movq %rax, %rbp
movq (%r15), %rdi
pushq $0xe
popq %rsi
callq 0x1fdc2
movq %rax, 0x20(%rbp)
movq (%r15), %rdi
pushq $0x45
popq %rsi
movq %r15, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %rbp
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rbp)
movq (%r12,%r13,8), %rdi
callq 0x1b5e6
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
cmpl $0x37, %eax
jne 0x273dd
movq %rbp, %rdx
callq 0x27353
jmp 0x273fb
callq 0x26f9c
movq %r14, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x26f11
movq %r14, %rdi
movq %rax, %rsi
callq 0x26164
incq %r13
jmp 0x27376
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_O2/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
xorl %eax, %eax
movq %rsp, %r15
movq %rax, (%rsp)
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x29e1a
testl %eax, %eax
je 0x275ff
movq 0x8(%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %r12
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x275eb
movq 0x18(%r12), %rcx
movq -0x8(%rcx,%rax,8), %rdi
callq 0x1b5e6
cmpl $0x2f, %eax
je 0x275f6
cmpl $0x3b, %eax
je 0x275f6
jmp 0x2760b
movq %r14, %rdi
movq %r12, %rsi
callq 0x27593
movq (%rsp), %rax
incq %rax
jmp 0x275a6
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 0xd5be(%rip), %rsi      # 0x34bdf
xorl %eax, %eax
callq 0x120fd
// File: /workspace/github_c_makefile_star2_O2/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 0x1c153
movl 0x18(%r15), %ecx
cmpq $0x7, %rcx
ja 0x27909
leaq 0xd3f4(%rip), %rdx      # 0x34c24
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x30(%r15), %r8d
leaq 0xd4a7(%rip), %rdx      # 0x34ceb
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2ad06
movl 0x30(%r15), %r8d
movq 0x38(%r15), %r9
leaq 0xd4bc(%rip), %rdx      # 0x34d23
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2ad06
movq 0x30(%r15), %r8
leaq 0xd480(%rip), %rdx      # 0x34d06
jmp 0x278f5
movsd 0x30(%r15), %xmm0
leaq 0xd480(%rip), %rdx      # 0x34d15
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x2ad06
leaq 0xd430(%rip), %rdx      # 0x34ce0
jmp 0x278d9
cmpl $0x0, 0x30(%r15)
leaq 0x7453(%rip), %rcx      # 0x2ed11
leaq 0x7447(%rip), %r8       # 0x2ed0c
cmoveq %rcx, %r8
leaq 0xd428(%rip), %rdx      # 0x34cf8
jmp 0x278f5
leaq 0xd466(%rip), %rdx      # 0x34d3f
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2ad06
movq 0x30(%r15), %r8
leaq 0xd43d(%rip), %rdx      # 0x34d32
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2ad06
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd42c(%rip), %r15      # 0x34d56
cmpb $0x0, 0x28(%rbx)
je 0x27950
movq 0x10(%rbx), %rdi
callq 0x1c153
movq %r14, %rdi
movl %r13d, %esi
leaq 0xd404(%rip), %rdx      # 0x34d4a
movq %rax, %rcx
xorl %eax, %eax
callq 0x2ad06
leaq 0x1(%r13), %rbp
xorl %r12d, %r12d
cmpq 0x48(%rbx), %r12
jae 0x27992
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x27804
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x2790f
incq %r12
jmp 0x27957
cmpq $0x0, 0x50(%rbx)
je 0x279c1
movq 0x10(%rbx), %rdi
callq 0x1c153
movq %r14, %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2ad06
movq 0x50(%rbx), %rbx
movq %rbp, %r13
jmp 0x2792a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/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, %rbx
movq (%rdi), %rax
leaq (%rax,%rax,2), %r14
incq %r14
movq %r14, %rdi
callq 0x29a78
movq %rax, %r15
leaq 0xd363(%rip), %r12      # 0x34d64
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq (%r15,%r13), %rdi
cmpq (%rbx), %rbp
jae 0x27a30
movq %r14, %rsi
subq %r13, %rsi
movq 0x8(%rbx), %rax
movl (%rax,%rbp,4), %ecx
movq %r12, %rdx
xorl %eax, %eax
callq 0x4150
cltq
addq %rax, %r13
incq %rbp
jmp 0x27a06
movb $0x0, -0x1(%rdi)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/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
movq %rdi, %r14
leaq 0xd30f(%rip), %r15      # 0x34d6a
xorl %r12d, %r12d
cmpq (%r14), %r12
jae 0x27a7d
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4240
incq %r12
jmp 0x27a5e
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x41f0
// File: /workspace/github_c_makefile_star2_O2/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 0x28b66
movq %rax, %r15
xorl %edi, %edi
xorl %esi, %esi
callq 0x291cf
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x28b9b
testq %r15, %r15
je 0x27f40
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x29b2d
movq 0x40(%r15), %r15
jmp 0x27f27
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x28(%rdi)
je 0x2859a
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq 0x48(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x285ae
cmpq $0x0, 0x50(%rbx)
je 0x285d0
pushq $0x1
popq %rbp
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x2858d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2857d
testl %eax, %eax
cmovel %eax, %ebp
incq %r15
jmp 0x285b4
xorl %ebp, %ebp
jmp 0x285b1
// File: /workspace/github_c_makefile_star2_O2/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 0x285f1
movq %rdi, %rbx
movb $0x1, 0x29(%rdi)
cmpb $0x0, 0x28(%rdi)
je 0x285f6
pushq $0x1
popq %r14
jmp 0x28638
xorl %r14d, %r14d
jmp 0x28638
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq 0x48(%rbx), %r15
jae 0x2861d
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
cmpb $0x0, 0x29(%rdi)
jne 0x28618
callq 0x285d4
addq %rax, %r14
incq %r15
jmp 0x285fc
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x28634
cmpb $0x0, 0x29(%rdi)
jne 0x28634
callq 0x285d4
addq %rax, %r14
addq 0x68(%rbx), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28657
movq %rdi, %r14
cmpb $0x0, 0x28(%rdi)
je 0x2865b
xorl %ebx, %ebx
jmp 0x28695
movq 0x48(%r14), %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x28682
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x28641
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %r12
jmp 0x28664
movq 0x50(%r14), %rdi
callq 0x28641
cmpq %rbx, %rax
cmovaq %rax, %rbx
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/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 0x286df
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x48(%rbx), %r14
jae 0x286cb
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x286a4
incq %r14
jmp 0x286b3
movq 0x50(%rbx), %rdi
callq 0x286a4
movb $0x0, 0x29(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbp
movq %rdi, %rdx
andq $0x0, 0x368fc(%rip)     # 0x5f270
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
xorl %edi, %edi
movq %r12, %r8
movq %r13, %r9
callq 0x27eed
movq (%r12), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x29c8c
movq (%r15), %rdi
pushq $0x34
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1b718
pushq $0x1
popq %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x27eed
movq (%r12), %rdi
movq (%r13), %rsi
callq 0x27f4a
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x286e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, (%rsp)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
leaq 0x20(%rsp), %r15
andq $0x0, (%r15)
movq 0x20(%rdi), %r13
movq %rdi, 0x18(%rsp)
movq 0x28(%rdi), %rbp
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x28a68
movq (%rbp,%r12,8), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x1bc4f
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x29b2d
incq %r12
jmp 0x28a3d
movq 0x18(%rsp), %r15
movq (%r15), %rdi
callq 0x1bc4f
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x27a93
movq %rax, (%rsp)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x286e0
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x28b0b
movq (%rbp,%r12,8), %rax
movq (%rax), %rdi
pushq $0x30
popq %rsi
movq 0x10(%rsp), %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1b718
movq %rax, %r15
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x1fdc2
movq %rax, 0x20(%r15)
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29b2d
movq (%rbp,%r12,8), %rax
movq 0x20(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29b2d
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x29b2d
incq %r12
jmp 0x28aa0
movq %r14, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x29b2d
leaq 0x356be(%rip), %rax     # 0x5e1e0
cmpb $0x0, 0x6d(%rax)
je 0x28b57
movq 0x184a1(%rip), %r15     # 0x40fd0
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x279d0
xorl %r12d, %r12d
cmpq (%rbx), %r12
jae 0x28b57
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%r15), %rsi
callq 0x1201b
incq %r12
jmp 0x28b3e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x48
popq %rdi
callq 0x29a78
movq %rax, %r14
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x2923b
movq %rax, 0x30(%r14)
movb $0x1, 0x28(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x29a78
movq %rax, %rbx
testq %r14, %r14
je 0x2921e
movq (%r14), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x29a78
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 0x29230
pushq $0x10
popq %rdi
callq 0x29a78
movq %rax, 0x8(%rbx)
andl $0x0, (%rax)
pushq $0x1
popq %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/mi/match.c
// Function: mkdtree
static Dtree *
mkdtree(Srcloc loc, Node *lbl)
{
	Dtree *t;

	t = zalloc(sizeof(Dtree));
	t->lbl = lbl;
	t->loc = loc;
	t->id = ndtree;
	lappend(&dtree, &ndtree, t);
	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x70
popq %rdi
callq 0x29a78
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x4(%rax)
leaq 0x36010(%rip), %rsi     # 0x5f270
movl 0x3600a(%rip), %eax     # 0x5f270
movl %eax, (%r15)
leaq 0x36008(%rip), %rdi     # 0x5f278
movq %r15, %rdx
callq 0x29b2d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x29a78
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
cmpq $0x1, %r15
je 0x292ae
popq %rbx
popq %r14
popq %r15
retq
leaq 0xbc6d(%rip), %rdi      # 0x34f22
leaq 0xbba9(%rip), %rsi      # 0x34e65
leaq 0xbc71(%rip), %rcx      # 0x34f34
pushq $0x46
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6fc
movq %rax, %r14
movq (%rbx), %rdi
pushq $0xe
popq %rsi
callq 0x1fdc2
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
pushq $0x28
popq %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1b718
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x1fcd8
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_O2/oridb[P]mc/mi/match.c
// Function: patheq
static int
patheq(Path *a, Path *b)
{
	size_t i;

	if (a->len != b->len)
		return 0;

	for (i = 0; i < a->len; i++) {
		if (a->p[i] != b->p[i])
			return 0;
	}
	return 1;
}

// Assembly:
movq (%rdi), %rcx
cmpq (%rsi), %rcx
jne 0x29376
xorl %edx, %edx
pushq $0x1
popq %rax
cmpq %rdx, %rcx
je 0x29378
movq 0x8(%rdi), %r8
movl (%r8,%rdx,4), %r8d
movq 0x8(%rsi), %r9
leaq 0x1(%rdx), %r10
cmpl (%r9,%rdx,4), %r8d
movq %r10, %rdx
je 0x29358
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5e6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1b5e6
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %ebp
jne 0x293ad
movq %r14, %rdi
callq 0x1b5e6
leal -0x33(%rax), %ecx
cmpl $0x2, %ecx
jae 0x293b2
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x35, %eax
jne 0x293ce
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1bfba
leaq 0xbc79(%rip), %rdi      # 0x3504e
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/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
cmpq %rbx, %r14
sete %r15b
je 0x29534
movq %r14, %rdi
callq 0x1b5e6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1b5e6
cmpl %eax, %ebp
jne 0x29534
movq %r14, %rdi
callq 0x1b5e6
leal -0x43(%rax), %ecx
cmpl $0x2, %ecx
jb 0x29499
cmpl $0x13, %eax
jne 0x294a9
movq 0x50(%r14), %rax
movq (%rax), %r14
movq 0x50(%rbx), %rax
movq (%rax), %rbx
jmp 0x2945d
cmpl $0x28, %eax
je 0x294c1
cmpl $0x2a, %eax
je 0x294fd
cmpl $0x33, %eax
je 0x29534
cmpl $0x45, %eax
jne 0x29543
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
callq 0x29450
testl %eax, %eax
je 0x29531
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 0x1bfba
jmp 0x29529
movq 0x50(%r14), %rax
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rsi
callq 0x29450
testl %eax, %eax
je 0x29531
movq 0x50(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x1c100
testl %eax, %eax
setne %r15b
jmp 0x29534
xorl %r15d, %r15d
movzbl %r15b, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbb04(%rip), %rdi      # 0x3504e
xorl %eax, %eax
callq 0x1205c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x1b5e6
addl $-0x1d, %eax
cmpl $0x2a, %eax
ja 0x295b9
movabsq $0x9800007ff, %rcx      # imm = 0x9800007FF
btq %rax, %rcx
jae 0x29581
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rax
popq %rbx
retq
movabsq $0x60000000000, %rcx    # imm = 0x60000000000
btq %rax, %rcx
jae 0x295b9
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x12, %eax
jne 0x295b9
movq 0x50(%rbx), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x1b5e6
cmpl $0x33, %eax
je 0x2957c
xorl %ebx, %ebx
jmp 0x2957c
// File: /workspace/github_c_makefile_star2_O2/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), %r14
leaq 0xbae0(%rip), %r15      # 0x350b5
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29e1a
testl %eax, %eax
je 0x29604
movq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4140
movq 0x8(%rsp), %rax
incq %rax
jmp 0x295d7
pushq $0xa
popq %rdi
callq 0x4050
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
cmpq 0x20(%rbx), %r14
jae 0x29a27
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x29d60
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x29d60
incq %r14
jmp 0x29a03
xorl %r14d, %r14d
leaq 0x34f2f(%rip), %r15     # 0x5e960
cmpq (%r15), %r14
jae 0x29a48
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4040
incq %r14
jmp 0x29a31
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
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/alloc.c
// Function: zalloc
void *
zalloc(size_t sz)
{
	void *mem;

	mem = calloc(1, sz);
	if (!mem && sz)
		die("Out of memory");
	return mem;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x4220
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x29a99
popq %rbx
retq
leaq 0xb61a(%rip), %rdi      # 0x350ba
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/alloc.c
// Function: xalloc
void *
xalloc(size_t sz)
{
	void *mem;

	mem = malloc(sz);
	if (!mem && sz)
		die("Out of memory");
	return mem;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4280
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x29ac2
popq %rbx
retq
leaq 0xb5f1(%rip), %rdi      # 0x350ba
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/alloc.c
// Function: xrealloc
void *
xrealloc(void *mem, size_t sz)
{
	mem = realloc(mem, sz);
	if (!mem && sz)
		die("Out of memory");
	return mem;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x42a0
testq %rax, %rax
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
je 0x29b1f
popq %rbx
retq
leaq 0xb594(%rip), %rdi      # 0x350ba
xorl %eax, %eax
callq 0x1205c
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/alloc.c
// Function: ldel
void
ldel(void *p, size_t *len, size_t idx)
{
	void ***pl, **l;

	assert(p != NULL);
	assert(idx < *len);
	pl = p;
	l = *pl;
	memmove(&l[idx], &l[idx + 1], (*len - idx - 1) * sizeof(void *));
	(*len)--;
	*pl = xrealloc(l, *len * sizeof(void *));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x29c56
movq %rsi, %r14
movq (%rsi), %rax
cmpq %rdx, %rax
jbe 0x29c6f
movq %rdi, %rbx
movq (%rdi), %r15
leaq (%r15,%rdx,8), %rdi
leaq (%r15,%rdx,8), %rsi
addq $0x8, %rsi
notq %rdx
addq %rdx, %rax
shlq $0x3, %rax
movq %rax, %rdx
callq 0x42b0
movq (%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
leaq -0x8(,%rax,8), %rsi
movq %r15, %rdi
callq 0x29b04
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb46b(%rip), %rdi      # 0x350c8
leaq 0xb46e(%rip), %rsi      # 0x350d2
leaq 0xb46f(%rip), %rcx      # 0x350da
pushq $0x68
jmp 0x29c86
leaq 0xb488(%rip), %rdi      # 0x350fe
leaq 0xb455(%rip), %rsi      # 0x350d2
leaq 0xb456(%rip), %rcx      # 0x350da
pushq $0x69
popq %rdx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/alloc.c
// Function: lfree
void
lfree(void *l, size_t *len)
{
	void ***pl;

	assert(l != NULL);
	pl = l;
	free(*pl);
	*pl = NULL;
	*len = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29cee
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x4040
andq $0x0, (%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x91dd(%rip), %rdi      # 0x32ed2
leaq 0xb3d6(%rip), %rsi      # 0x350d2
leaq 0xb406(%rip), %rcx      # 0x35109
movl $0x82, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: mkbs
Bitset *
mkbs()
{
	Bitset *bs;

	bs = xalloc(sizeof(Bitset));
	bs->nchunks = 1;
	bs->chunks = zalloc(1 * sizeof(size_t));
	return bs;
}

// Assembly:
pushq %rbx
pushq $0x10
popq %rdi
callq 0x29aa7
movq %rax, %rbx
movq $0x1, (%rax)
pushq $0x8
popq %rdi
callq 0x29a78
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsdup
Bitset *
bsdup(Bitset *a)
{
	Bitset *bs;

	if (!a)
		return NULL;
	bs = xalloc(sizeof(Bitset));
	bs->nchunks = a->nchunks;
	bs->chunks = xalloc(a->nchunks * sizeof(size_t));
	memcpy(bs->chunks, a->chunks, a->nchunks * sizeof(size_t));
	return bs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29dbb
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x29aa7
movq %rax, %rbx
movq (%r14), %rdi
movq %rdi, (%rax)
shlq $0x3, %rdi
callq 0x29aa7
movq %rax, 0x8(%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x4270
jmp 0x29dbd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bsclear
Bitset *
bsclear(Bitset *bs)
{
	size_t i;

	if (!bs)
		return mkbs();
	for (i = 0; i < bs->nchunks; i++)
		bs->chunks[i] = 0;
	return bs;
}

// Assembly:
testq %rdi, %rdi
je 0x29d3c
xorl %eax, %eax
cmpq (%rdi), %rax
jae 0x29de6
movq 0x8(%rdi), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x29dd3
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/oridb[P]mc/util/bitset.c
// Function: bscount
size_t
bscount(Bitset *bs)
{
	size_t i, j, n;

	n = 0;
	for (i = 0; i < bs->nchunks; i++)
		for (j = 0; j < sizeof(size_t) * CHAR_BIT; j++)
			if (bs->chunks[i] & 1ULL << j)
				n++;
	return n;
}

// Assembly:
movq (%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x29e19
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %r8d, %r8d
cmpq $0x40, %r8
je 0x29e14
btq %r8, %rsi
adcq $0x0, %rax
incq %r8
jmp 0x29e01
incq %rdx
jmp 0x29df1
retq