LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x58(%rbp), %r9
leaq -0x30(%rbp), %r10
leaq -0x50(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x46030
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x4317f
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41220
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x43152
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x41220
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x431c1
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41220
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x43194
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x42420
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x37, %eax
jne 0x43349
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x43bc0
movq %rax, -0x20(%rbp)
jmp 0x433bc
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
cmpl $0x1, (%rax)
je 0x433a9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43560
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a40
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42ef0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x419f0
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x433ba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a40
movq %rax, -0x20(%rbp)
jmp 0x433bc
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattenlazy
static Node *
flattenlazy(Flattenctx *s, Node *n)
{
	Node *r, *t, *u;
	Node *ltrue, *lfalse, *ldone;

	/* set up temps and labels */
	r = temp(s, n);
	ltrue = genlbl(n->loc);
	lfalse = genlbl(n->loc);
	ldone = genlbl(n->loc);

	/* flatten the conditional */
	flattencond(s, n, ltrue, lfalse);


	/* if true */
	append(s, ltrue);
	u = mkexpr(n->loc, Olit, mkbool(n->loc, 1), NULL);
	u->expr.type = mktype(n->loc, Tybool);
	t = asn(r, u);
	append(s, t);
	jmp(s, ldone);

	/* if false */
	append(s, lfalse);
	u = mkexpr(n->loc, Olit, mkbool(n->loc, 0), NULL);
	u->expr.type = mktype(n->loc, Tybool);
	t = asn(r, u);
	append(s, t);
	jmp(s, ldone);

	/* finish */
	append(s, ldone);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43230
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x42580
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x419f0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x30120
movq %rax, %rdx
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42ef0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x42420
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x419f0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x30120
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42ef0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x42420
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x419f0
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x26, %eax
ja 0x4364d
movq -0x20(%rbp), %rax
leaq 0x112ae(%rip), %rcx     # 0x54844
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43230
movq %rax, -0x18(%rbp)
jmp 0x4367f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
movq -0x28(%rbp), %rdi
movl %eax, %eax
movl %eax, %ecx
leaq 0x38853(%rip), %rax     # 0x7bec0
movq (%rax,%rcx,8), %rdx
leaq 0xadba(%rip), %rsi      # 0x4e432
movb $0x0, %al
callq 0x1dfe0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattentern
static Node*
flattentern(Flattenctx *s, Node *n)
{
	Node *l1, *l2, *l3;
	Node *res, *t;

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

	res = temp(s, n);
	flattencond(s, n->expr.args[0], l1, l2);

	append(s, l1);
	t = assign(s, res, rval(s, n->expr.args[1]));
	append(s, t);
	jmp(s, l3);

	append(s, l2);
	t = assign(s, res, rval(s, n->expr.args[2]));
	append(s, t);

	append(s, l3);

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43230
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x41a40
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x43310
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42420
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x41a40
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x43310
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x419f0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x43af0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41a40
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x43aa8
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %eax
movl %eax, %ecx
leaq 0x389bc(%rip), %rax     # 0x7c4c0
cmpl $0x0, (%rax,%rcx,4)
je 0x43b17
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x43bb6
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x1, (%rax)
jne 0x43b82
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x301c0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x35, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x419f0
jmp 0x43bb4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43230
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42ef0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x419f0
jmp 0x43bb6
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x43cf1
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rsi
movq (%rax), %rdi
callq 0x2f3c0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0xe, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq (%rax), %rdi
movl $0x45, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f210
cmpl $0x37, %eax
jne 0x43ca0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x43bc0
jmp 0x43cde
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x43560
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x43310
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x419f0
jmp 0x43ce0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x43bf9
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/dfcheck.c
// Function: checkret
static void
checkret(Cfg *cfg)
{
	Type *ft;

	ft = tybase(decltype(cfg->fn));
	assert(ft->type == Tyfunc || ft->type == Tycode);
	if (ft->sub[0]->type == Tyvoid)
		return;

	checkpredret(cfg, cfg->end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, (%rax)
je 0x43f96
movq -0x10(%rbp), %rax
cmpl $0x1e, (%rax)
jne 0x43f98
jmp 0x43fb7
leaq 0x110f8(%rip), %rdi     # 0x55097
leaq 0x1111a(%rip), %rsi     # 0x550c0
movl $0x81, %edx
leaq 0x11118(%rip), %rcx     # 0x550ca
callq 0x6160
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x43fc9
jmp 0x43fda
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x44170
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/dfcheck.c
// Function: checkreach
static void
checkreach(Cfg *cfg)
{
	Bitset *reach, *kill;
	size_t i, j, k;
	Reaching *r;
	Node *n, *m;
	Bb *bb;

	r = reaching(cfg);
	for (i = 0; i < cfg->nbb; i++) {
		bb = cfg->bb[i];
		if (!bb)
			continue;
		reach = bsdup(r->in[i]);
		kill = mkbs();
		for (j = 0; j < bb->nnl; j++) {
			n = bb->nl[j];
			if (exprop(n) == Oundef) {
				bsput(reach, n->nid);
			} else {
				m = assignee(n);
				if (m)
					for (k = 0; k < r->ndefs[m->expr.did]; k++)
						bsput(kill, r->defs[m->expr.did][k]);
				checkundef(n, r, reach, kill);
			}
		}
		bsfree(reach);
		bsfree(kill);
	}
	reachingfree(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x47a80
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x4415c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x44033
jmp 0x4414b
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x486d0
movq %rax, -0x10(%rbp)
callq 0x48650
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x44139
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2f210
cmpl $0x3c, %eax
jne 0x440a6
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movslq 0xc(%rax), %rsi
callq 0x48a50
jmp 0x44126
movq -0x40(%rbp), %rdi
callq 0x47960
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x44111
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x48(%rbp), %rdx
movq 0x38(%rdx), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x4410f
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x48(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x48a50
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x440c2
jmp 0x44111
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x44240
jmp 0x44128
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4405c
movq -0x10(%rbp), %rdi
callq 0x48690
movq -0x18(%rbp), %rdi
callq 0x48690
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x44001
movq -0x38(%rbp), %rdi
callq 0x48080
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x44237
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x441d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44170
jmp 0x44224
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f210
movl %eax, -0x1c(%rbp)
cmpl $0x2f, -0x1c(%rbp)
je 0x44222
cmpl $0x3b, -0x1c(%rbp)
je 0x44222
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x10ec4(%rip), %rsi     # 0x550df
movb $0x0, %al
callq 0x1dfe0
jmp 0x44224
jmp 0x44226
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x44188
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x30710
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x7, %rax
ja 0x44764
movq -0x30(%rbp), %rax
leaq 0x10b0b(%rip), %rcx     # 0x55124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
leaq 0x10cfd(%rip), %rdx     # 0x55330
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x30(%rax), %r8d
leaq 0x10cdf(%rip), %rdx     # 0x5533b
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0xa4b9(%rip), %r8       # 0x4eb3d
leaq 0xa4ad(%rip), %rax      # 0x4eb38
cmpl $0x0, %edx
cmovneq %rax, %r8
leaq 0x10caf(%rip), %rdx     # 0x55348
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
leaq 0x10c94(%rip), %rdx     # 0x55356
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
leaq 0x10c79(%rip), %rdx     # 0x55365
movb $0x1, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, %r8d
movq -0x18(%rbp), %rax
movq 0x38(%rax), %r9
leaq 0x10c56(%rip), %rdx     # 0x55373
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r8
leaq 0x10c3f(%rip), %rdx     # 0x55382
movb $0x0, %al
callq 0x4a710
jmp 0x44764
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
leaq 0x10c32(%rip), %rdx     # 0x5538f
movb $0x0, %al
callq 0x4a710
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x447c2
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x30710
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq %rax, %rcx
leaq 0x10bdf(%rip), %rdx     # 0x5539a
movb $0x0, %al
callq 0x4a710
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x4482f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
callq 0x445d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x44770
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x447ca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x44887
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x30710
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq %rax, %rcx
leaq 0x10b3f(%rip), %rdx     # 0x553a6
movb $0x0, %al
callq 0x4a710
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
callq 0x44770
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
imulq $0x3, (%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48160
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4494b
movq -0x28(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x10a88(%rip), %rdx     # 0x553b4
movb $0x0, %al
callq 0x6130
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x448f9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x449c4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x10a0b(%rip), %rsi     # 0x553ba
movb $0x0, %al
callq 0x6230
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x44988
movq -0x10(%rbp), %rdi
leaq 0x91e7(%rip), %rsi      # 0x4dbb6
movb $0x0, %al
callq 0x6230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: genfrontier
static void
genfrontier(int i, Node *val, Node *pat, Node *lbl, Frontier ***frontier, size_t *nfrontier)
{
	Frontier *fs;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x46310
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x46cf0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
callq 0x46380
cmpq $0x0, -0x38(%rbp)
je 0x44f1c
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x48290
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x44ef6
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: capcompatible
static int
capcompatible(Node *a, Node *b)
{
	Node *pa, *pb, *va, *vb;

	pa = a->expr.args[0];
	pb = b->expr.args[0];
	va = a->expr.args[1];
	vb = b->expr.args[1];

	return pa->expr.did == pb->expr.did && tyeq(exprtype(va), exprtype(vb));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rdx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
movb %al, -0x31(%rbp)
jne 0x44fc0
movq -0x28(%rbp), %rdi
callq 0x30340
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x30340
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x39360
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x459bf
movl $0x1, -0x4(%rbp)
jmp 0x45a37
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x459e3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x459ea
movl $0x1, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x45a31
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x459a0
cmpl $0x0, %eax
jne 0x45a21
movl $0x0, -0x1c(%rbp)
jmp 0x45a23
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x459f2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x45a60
movq $0x0, -0x8(%rbp)
jmp 0x45b1e
movq -0x10(%rbp), %rax
movb $0x1, 0x29(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x45a7f
movq $0x1, -0x8(%rbp)
jmp 0x45b1e
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x45ae0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0x29(%rax)
jne 0x45ad0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a40
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x45ad2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x45a8f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x45b0e
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpb $0x0, 0x29(%rax)
jne 0x45b0e
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x45a40
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x45b50
movq $0x0, -0x8(%rbp)
jmp 0x45bef
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x45b67
movq $0x0, -0x8(%rbp)
jmp 0x45bef
movq $0x0, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x45bc0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45b30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x45bb0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x45bb2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x45b77
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x45b30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x45be3
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x45c15
jmp 0x45c63
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x45c4e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45c00
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x45c1d
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x45c00
movq -0x8(%rbp), %rax
movb $0x0, 0x29(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, 0x37d25(%rip) # 0x7dd88
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x44e90
movq 0x10(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rcx
callq 0x48510
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x34, %esi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x2f400
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %edi
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
callq 0x44e90
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x451d0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x45c70
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x48, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x46de0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movb $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x46d7c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
shlq $0x2, %rdi
callq 0x48160
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
shlq $0x2, %rdx
callq 0x6260
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x46daa
movl $0x10, %edi
callq 0x48160
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x46db7
jmp 0x46dd6
leaq 0xe7eb(%rip), %rdi      # 0x555a9
leaq 0xe6f0(%rip), %rsi      # 0x554b5
movl $0x144, %edx            # imm = 0x144
leaq 0xe7e5(%rip), %rcx      # 0x555b6
callq 0x6160
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x70, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x4(%rax)
movq 0x36f6b(%rip), %rax     # 0x7dd88
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdx
leaq 0x36f60(%rip), %rdi     # 0x7dd90
leaq 0x36f51(%rip), %rsi     # 0x7dd88
callq 0x48290
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: frontierdup
static Frontier *
frontierdup(Frontier *fs)
{
	Frontier *out;

	out = mkfrontier(fs->i, fs->lbl);
	out->slot = memdup(fs->slot, fs->nslot*sizeof(fs->slot[0]));
	out->nslot = fs->nslot;
	out->cap = memdup(fs->cap, fs->ncap*sizeof(fs->cap[0]));
	out->ncap = fs->ncap;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x46310
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x48160
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %eax
cmpq %rax, -0x8(%rbp)
je 0x46f42
jmp 0x46f61
leaq 0xe629(%rip), %rdi      # 0x55572
leaq 0xe565(%rip), %rsi      # 0x554b5
movl $0x46, %edx
leaq 0xe628(%rip), %rcx      # 0x55584
callq 0x6160
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x2f3c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xe, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq (%rax), %rdi
movl $0x28, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq 0x68(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: tupelt
static Node *
tupelt(Node *n, size_t i)
{
	Node *idx, *elt;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x2f3c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xe, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq (%rax), %rdi
movl $0x45, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: findmemb
static Node *
findmemb(Node *pat, Node *name)
{
	Node *n;
	size_t i;

	for (i = 0; i < pat->expr.nargs; i++) {
		n = pat->expr.args[i];
		if (nameeq(n->expr.idx, name))
			return n;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x4720a
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x30670
cmpl $0x0, %eax
je 0x471fa
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x47212
jmp 0x471fc
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x471b8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x47245
movl $0x0, -0x4(%rbp)
jmp 0x4729a
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x47293
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x47283
movl $0x0, -0x4(%rbp)
jmp 0x4729a
jmp 0x47285
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4724d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
je 0x472d7
movl $0x0, -0x4(%rbp)
jmp 0x47332
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, %eax
addl $-0x33, %eax
movl %ecx, -0x20(%rbp)
subl $0x2, %eax
jb 0x4731b
jmp 0x472f1
movl -0x20(%rbp), %eax
subl $0x35, %eax
jne 0x47324
jmp 0x472fb
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x30390
movl %eax, -0x4(%rbp)
jmp 0x47332
movl $0x1, -0x4(%rbp)
jmp 0x47332
leaq 0xe39a(%rip), %rdi      # 0x556c5
movb $0x0, %al
callq 0x1df20
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/match.c
// Function: dtreusable
static int
dtreusable(Dtree *dt, Node *load, Node **pat, size_t npat, Dtree **next, size_t nnext, Dtree *any)
{
	size_t i;

	if (!loadeq(dt->load, load))
		return 0;

	if (dt->npat != npat)
		return 0;

	for (i = 0; i < npat; i++) {
		if (dt->next[i]->id != next[i]->id)
			return 0;
		if (!pateq(dt->pat[i], pat[i]))
			return 0;
	}

	if (dt->any == NULL && any == NULL)
		return 1;

	if (dt->any->id != any->id)
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x477c0
cmpl $0x0, %eax
jne 0x47536
movl $0x0, -0x4(%rbp)
jmp 0x47609
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0x47550
movl $0x0, -0x4(%rbp)
jmp 0x47609
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x475cc
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
je 0x4758d
movl $0x0, -0x4(%rbp)
jmp 0x47609
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x472a0
cmpl $0x0, %eax
jne 0x475bc
movl $0x0, -0x4(%rbp)
jmp 0x47609
jmp 0x475be
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x47558
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x475e7
cmpq $0x0, 0x10(%rbp)
jne 0x475e7
movl $0x1, -0x4(%rbp)
jmp 0x47609
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax), %eax
movq 0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x47602
movl $0x0, -0x4(%rbp)
jmp 0x47609
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)