LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: protomap
static void
protomap(Trait *tr, Type *ty, Node *dcl)
{
	size_t i, len;
	char *protoname, *dclname, *p;
	Node *proto, *n;
	Stab *st;

	dclname = declname(dcl);
	for (i = 0; i < tr->nproto; i++) {
		n = tr->proto[i]->decl.name;
		st = file.globls;
		if (n->name.ns)
			st = getns(n->name.ns);
		proto = getdcl(st, n);
		if (!proto)
			proto = tr->proto[i];
		protoname = declname(proto);
		len = strlen(protoname);
		p = strstr(dclname, protoname);
		if (!p || p[len] != '$')
			continue;
		if (hthas(proto->decl.impls, ty))
			continue;
		htput(proto->decl.impls, ty, dcl);
		if (ty->type == Tygeneric || hasparams(ty)) {
			lappend(&proto->decl.gimpl, &proto->decl.ngimpl, dcl);
			lappend(&proto->decl.gtype, &proto->decl.ngtype, ty);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30200
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x3fcee
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0x3d1de(%rip), %rax     # 0x7cd98
movq 0x90(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3fbe1
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x330b0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x334b0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3fc0d
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x30200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6360
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3fc50
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
je 0x3fc55
jmp 0x3fcdd
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x3fc6d
jmp 0x3fcdd
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x49100
movq -0x10(%rbp), %rax
cmpl $0x1d, (%rax)
je 0x3fc99
movq -0x10(%rbp), %rdi
callq 0x37ce0
cmpl $0x0, %eax
je 0x3fcdb
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
addq $0x38, %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
callq 0x48290
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
addq $0x48, %rdi
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
addq $0x50, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
jmp 0x3fcdd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3fb89
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: wrtype
static void
wrtype(FILE *fd, Type *ty)
{
	if (!ty) {
		wrint(fd, 0);
		return;
	}
	if (ty->tid >= Builtinmask)
		die("Type id %d for %s too big", ty->tid, tystr(ty));
	if (ty->vis == Visbuiltin)
		wrint(fd, ty->type | Builtinmask);
	else
		wrint(fd, ty->tid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fd26
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49fb0
jmp 0x3fd90
movq -0x10(%rbp), %rax
cmpl $0x40000000, 0x4(%rax)  # imm = 0x40000000
jb 0x3fd5a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38a10
movl -0x14(%rbp), %esi
movq %rax, %rdx
leaq 0x148c6(%rip), %rdi     # 0x54619
movb $0x0, %al
callq 0x1df20
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x3fd7e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, %eax
movl %eax, %esi
callq 0x49fb0
jmp 0x3fd90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x49fb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: wrucon
static void
wrucon(FILE *fd, Ucon *uc)
{
	wrint(fd, uc->loc.line);
	wrint(fd, uc->id);
	wrbool(fd, uc->synth);
	pickle(fd, uc->name);
	wrbool(fd, uc->etype != NULL);
	if (uc->etype)
		wrtype(fd, uc->etype);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x49fb0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x4a2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3f0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4a2f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3fe28
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x3fd00
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/use.c
// Function: wrstab
static void
wrstab(FILE *fd, Stab *val)
{
	size_t n, i;
	void **keys;

	wrstr(fd, val->name);

	/* write decls */
	keys = htkeys(val->dcl, &n);
	wrint(fd, n);
	for (i = 0; i < n; i++)
		wrsym(fd, getdcl(val, keys[i]));
	free(keys);

	/* write types */
	keys = htkeys(val->ty, &n);
	wrint(fd, n);
	for (i = 0; i < n; i++) {
		pickle(fd, keys[i]);			/* name */
		wrtype(fd, gettype(val, keys[i]));	/* type */
	}
	free(keys);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4a020
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x49fb0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3febc
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x334b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3f700
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3fe7b
movq -0x28(%rbp), %rdi
callq 0x6040
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x49fb0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3ff45
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3f0b0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x33750
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3fd00
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3feef
movq -0x28(%rbp), %rdi
callq 0x6040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: delete
void
delete(Cfg *cfg, Bb *bb)
{
	size_t i, j;

	if (bb == cfg->start || bb == cfg->end)
		return;
	for (i = 0; bsiter(bb->pred, &i); i++) {
		bsunion(cfg->bb[i]->succ, bb->succ);
		bsdel(cfg->bb[i]->succ, bb->id);
	}
	for (i = 0; bsiter(bb->succ, &i); i++) {
		bsunion(cfg->bb[i]->pred, bb->pred);
		bsdel(cfg->bb[i]->pred, bb->id);
		for (j = 0; j < bb->nlbls; j++)
			strlabel(cfg, bb->lbls[j], cfg->bb[i]);
	}
	cfg->bb[bb->id] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x3ff8c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x3ff91
jmp 0x400d8
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x3fffe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x48b40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x48af0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ff99
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x400c1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x48b40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x48af0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x400ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x400e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x40069
jmp 0x400b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x40006
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: noexit
void
noexit(Cfg *cfg, Bb *bb)
{
	size_t i;
	for (i = 0; bsiter(bb->succ, &i); i++)
		bsdel(cfg->bb[i]->pred, bb->id);
	bsclear(bb->succ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x4019c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x48af0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x40158
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x48760
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: trimdead
void
trimdead(Cfg *cfg, Bb *bb)
{
	size_t i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x401cc
jmp 0x402a9
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x402a9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f210
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x11, %eax
ja 0x40294
movq -0x20(%rbp), %rax
leaq 0x1441c(%rip), %rcx     # 0x54634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x402a9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40140
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x402a9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x402b0
cmpl $0x0, %eax
je 0x40292
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40140
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x402a9
jmp 0x40296
jmp 0x40296
jmp 0x40298
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x401d4
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: isnonretcall
static int
isnonretcall(Node *fn)
{
	Node *dcl;

	if (exprop(fn) != Ovar)
		return 0;
	dcl = decls[fn->expr.did];
	return dcl->decl.isnoret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
je 0x402d3
movl $0x0, -0x4(%rbp)
jmp 0x402f8
leaq 0x3d1ae(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x78(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: trim
void
trim(Cfg *cfg)
{
	Bb *bb;
	size_t i;
	int deleted;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x403ce
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x403c9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x4037a
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x4037c
jmp 0x403b8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x401b0
cmpq $0x0, -0x10(%rbp)
je 0x403b6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x48ee0
cmpl $0x0, %eax
je 0x403b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ff60
movl $0x1, -0x1c(%rbp)
jmp 0x403b8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4033c
jmp 0x40323
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: mkbb
static Bb *
mkbb(Cfg *cfg)
{
	Bb *bb;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
callq 0x48650
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x48650
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
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/cfg.c
// Function: islabel
static int
islabel(Node *n)
{
	Node *l;
	if (n->type != Nexpr)
		return 0;
	if (exprop(n) != Olit)
		return 0;
	l = n->expr.args[0];
	if (l->type != Nlit)
		return 0;
	if (l->lit.littype != Llbl)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
je 0x4092f
movl $0x0, -0x4(%rbp)
jmp 0x40982
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x40946
movl $0x0, -0x4(%rbp)
jmp 0x40982
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x9, 0x8(%rax)
je 0x40968
movl $0x0, -0x4(%rbp)
jmp 0x40982
movq -0x18(%rbp), %rax
cmpl $0x6, 0x18(%rax)
je 0x4097b
movl $0x0, -0x4(%rbp)
jmp 0x40982
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: addlabel
static Bb *
addlabel(Cfg *cfg, Bb *bb, Node **nl, size_t i, Srcloc loc)
{
	/* if the current block assumes fall-through, insert an explicit jump */
	if (i > 0 && nl[i - 1]->type == Nexpr) {
		if (exprop(nl[i - 1]) != Ocjmp && exprop(nl[i - 1]) != Ojmp)
			addnode(cfg, bb, mkexpr(loc, Ojmp, mklbl(loc, lblstr(nl[i])), NULL));
	}
	if (bb->nnl)
		bb = mkbb(cfg);
	label(cfg, nl[i], bb);
	return bb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x40a5b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x8, 0x8(%rax)
jne 0x40a5b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f210
cmpl $0x3e, %eax
je 0x40a59
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f210
cmpl $0x30, %eax
je 0x40a59
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30710
movq %rax, %rsi
movq -0x8(%rbp), %rdi
callq 0x2fbe0
movq %rax, %rdx
movq -0x8(%rbp), %rdi
movl $0x30, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x40aa0
jmp 0x40a5b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x40a73
movq -0x10(%rbp), %rdi
callq 0x40890
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x40bb0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: addnode
static int
addnode(Cfg *cfg, Bb *bb, Node *n)
{
	switch (exprop(n)) {
	case Ojmp:
	case Ocjmp:
	case Oret:
		lappend(&bb->nl, &bb->nnl, n);
		lappend(&cfg->fixjmp, &cfg->nfixjmp, n);
		lappend(&cfg->fixblk, &cfg->nfixblk, bb);
		return 1;
	case Ocall:
		lappend(&bb->nl, &bb->nnl, n);
		return isnonretcall(n->expr.args[0]);
	case Odead:
		lappend(&bb->nl, &bb->nnl, n);
		return 1;
	default:
		lappend(&bb->nl, &bb->nnl, n);
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f210
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x11, %eax
ja 0x40b87
movq -0x28(%rbp), %rax
leaq 0x13ba2(%rip), %rcx     # 0x5467c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
callq 0x48290
movl $0x1, -0x4(%rbp)
jmp 0x40ba7
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rdi
callq 0x402b0
movl %eax, -0x4(%rbp)
jmp 0x40ba7
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movl $0x1, -0x4(%rbp)
jmp 0x40ba7
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/cfg.c
// Function: dumpcfg
void
dumpcfg(Cfg *cfg, FILE *fd)
{
	size_t i;

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

// Assembly:
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 0x20(%rcx), %rax
jae 0x40c64
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x40c2b
jmp 0x40c56
movq -0x10(%rbp), %rdi
leaq 0xcf80(%rip), %rsi      # 0x4dbb6
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x40c70
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x40c08
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattenfn
Node *
flattenfn(Node *dcl)
{
	if (ismain(dcl))
		dcl->decl.vis = Vishidden;
	if (dcl->decl.isextern || dcl->decl.isgeneric)
		return dcl;
	if (isconstfn(dcl)) {
		dcl = flatteninit(dcl);
		//lappend(fn, nfn, f);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40fb0
cmpl $0x0, %eax
je 0x40f52
movq -0x10(%rbp), %rax
movb $0x2, 0x70(%rax)
movq -0x10(%rbp), %rax
movsbl 0x74(%rax), %eax
cmpl $0x0, %eax
jne 0x40f6c
movq -0x10(%rbp), %rax
movsbl 0x73(%rax), %eax
cmpl $0x0, %eax
je 0x40f76
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x40f99
movq -0x10(%rbp), %rdi
callq 0x41010
cmpl $0x0, %eax
je 0x40f91
movq -0x10(%rbp), %rdi
callq 0x41150
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: ismain
static int
ismain(Node *n)
{
	n = n->decl.name;
	if (n->name.ns)
		return 0;
	return strcmp(n->name.name, "main") == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x40fdc
movl $0x0, -0x4(%rbp)
jmp 0x40ffe
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0xcad7(%rip), %rsi      # 0x4dac2
callq 0x6220
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: isconstfn
int
isconstfn(Node *n)
{
	Node *d, *e;
	Type *t;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x4105c
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
je 0x41040
movl $0x0, -0x4(%rbp)
jmp 0x41144
leaq 0x3c441(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x41064
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x41097
movq -0x18(%rbp), %rax
cmpb $0x0, 0x72(%rax)
je 0x41097
movq -0x18(%rbp), %rax
movsbl 0x73(%rax), %eax
cmpl $0x0, %eax
je 0x410a3
movl $0x0, -0x4(%rbp)
jmp 0x41144
movq -0x18(%rbp), %rax
cmpb $0x0, 0x71(%rax)
jne 0x410c3
movq -0x18(%rbp), %rax
cmpb $0x0, 0x74(%rax)
jne 0x410c3
movl $0x0, -0x4(%rbp)
jmp 0x41144
movq -0x28(%rbp), %rax
cmpl $0x13, (%rax)
je 0x410de
movq -0x28(%rbp), %rax
cmpl $0x1e, (%rax)
je 0x410de
movl $0x0, -0x4(%rbp)
jmp 0x41144
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41119
movq -0x20(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
jne 0x41110
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x5, 0x18(%rax)
je 0x41119
movl $0x0, -0x4(%rbp)
jmp 0x41144
cmpq $0x0, -0x20(%rbp)
jne 0x4113d
movq -0x18(%rbp), %rax
cmpb $0x0, 0x74(%rax)
jne 0x4113d
movq -0x18(%rbp), %rax
cmpb $0x0, 0x77(%rax)
jne 0x4113d
movl $0x0, -0x4(%rbp)
jmp 0x41144
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flatteninit
static Node *
flatteninit(Node *dcl)
{
	Flattenctx fc = {0,};
	Node *lit, *fn, *blk, *body;

	lit = dcl->decl.init->expr.args[0];
	fn = lit->lit.fnval;
	body = fn->func.body;
	fc.curst = fn->func.scope;
	flatten(&fc, fn->func.body);
	blk = mkblock(fn->loc, body->block.scope);
	blk->block.stmts = fc.stmts;
	blk->block.nstmts = fc.nstmts;
	fn->func.body = blk;

	return dcl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x6180
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0x41220
movq -0x80(%rbp), %rax
movq -0x90(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq (%rax), %rdi
callq 0x2f980
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x60(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flatten
static Node *
flatten(Flattenctx *fc, Node *n)
{
	Node *r, *u, *t;

	if (!n)
		return NULL;
	r = NULL;
	switch (n->type) {
	case Nblock:	flattenblk(fc, n);	break;
	case Nloopstmt:	flattenloop(fc, n);	break;
	case Niterstmt:	flatteniter(fc, n);	break;
	case Nifstmt:	flattenif(fc, n, NULL);	break;
	case Nmatchstmt:	flattenmatch(fc, n);	break;
	case Nexpr:	flattenexpr(fc, n);     break;
	case Ndecl:
		append(fc, n);
		r = mkexpr(n->loc, Ovar, n->decl.name, NULL);
		if (n->decl.init) {
			t = rval(fc, n->decl.init);
			u = mkexpr(n->loc, Oasn, r, t, NULL);
			u->expr.type = n->decl.type;
			r->expr.type = n->decl.type;
			r->expr.did = n->decl.did;
			flatten(fc, u);
		}
		break;
	default:
		dumpn(n, stderr);
		die("bad node passsed to flatten()");
		break;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x41244
movq $0x0, -0x8(%rbp)
jmp 0x413c4
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0xa, %eax
ja 0x4139b
movq -0x38(%rbp), %rax
leaq 0x134b1(%rip), %rcx     # 0x54720
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x413d0
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x414f0
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x416c0
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x41730
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x418c0
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41980
jmp 0x413bc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x419f0
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq (%rax), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x41399
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x41a40
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq (%rax), %rdi
movl $0x1d, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41220
jmp 0x413bc
movq -0x18(%rbp), %rdi
movq 0x1dc4a(%rip), %rax     # 0x5eff0
movq (%rax), %rsi
callq 0x1de90
leaq 0x13b2b(%rip), %rdi     # 0x54ee0
movb $0x0, %al
callq 0x1df20
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattenblk
static void
flattenblk(Flattenctx *s, Node *n)
{
	Stab *st;
	size_t i;

	st = s->curst;
	s->curst = n->block.scope;
	for (i = 0; i < n->block.nstmts; i++) {
		n->block.stmts[i] = fold(n->block.stmts[i], 0);
		flatten(s, n->block.stmts[i]);
	}
	assert(s->curst == n->block.scope);
	if (st->isfunc)
		exitscope(s, NULL, Zloc, Xret);
	else
		dispose(s, s->curst, 0);
	s->curst = st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x41463
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x1f390
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41220
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x41404
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x41477
jmp 0x41496
leaq 0x13a80(%rip), %rdi     # 0x54efe
leaq 0x13a94(%rip), %rsi     # 0x54f19
movl $0x2ce, %edx            # imm = 0x2CE
leaq 0x13a92(%rip), %rcx     # 0x54f23
callq 0x6160
movq -0x18(%rbp), %rax
cmpb $0x0, 0x10(%rax)
je 0x414c6
movq -0x8(%rbp), %rdi
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %ecx
callq 0x42200
jmp 0x414db
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x42310
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flatteniter
static void
flatteniter(Flattenctx *s, Node *n)
{
	switch (tybase(exprtype(n->iterstmt.seq))->type) {
	case Tyarray:	flattenidxiter(s, n);	break;
	case Tyslice:	flattenidxiter(s, n);	break;
	default:	flattentraititer(s, n);	break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x14, %eax
je 0x4170a
jmp 0x416f1
movl -0x14(%rbp), %eax
subl $0x15, %eax
jne 0x41719
jmp 0x416fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x427a0
jmp 0x41726
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x427a0
jmp 0x41726
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42ab0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -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)
cmpq $0x0, -0x18(%rbp)
je 0x41775
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x41785
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x41a40
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x41800
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x43230
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42ef0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
callq 0x426c0
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x42580
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
callq 0x426c0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42420
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
callq 0x426c0
cmpq $0x0, -0x48(%rbp)
je 0x4187f
movq -0x48(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x4187f
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x41730
jmp 0x41899
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42420
cmpq $0x0, -0x18(%rbp)
jne 0x418ad
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x41220
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattenmatch
static void
flattenmatch(Flattenctx *fc, Node *n)
{
	Node *v, *r, **match;
	size_t i, nmatch;

	r = rval(fc, n->matchstmt.val);
	v = temp(fc, r);
	flatten(fc, asn(v, r));
	draininc(fc);

	match = NULL;
	nmatch = 0;
	genmatch(n, v, &match, &nmatch);
	for (i = 0; i < nmatch; i++)
		flatten(fc, match[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x41a40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43230
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x42ef0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x41220
movq -0x8(%rbp), %rdi
callq 0x426c0
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x46120
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x4197a
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x41220
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4194d
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/mi/flatten.c
// Function: flattenexpr
static void
flattenexpr(Flattenctx *fc, Node *n)
{
	Node *r;

	if (islbl(n)) {
		append(fc, n);
		return;
	}
	r = rval(fc, n);
	if (r)
		append(fc, r);
	draininc(fc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x432a0
cmpl $0x0, %eax
je 0x419ad
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x419f0
jmp 0x419db
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x419d2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
callq 0x426c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x60(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x78(%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x422a3
movq -0xc(%rbp), %rdi
callq 0x2fd00
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, 0x60(%rax,%rcx,8)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x60(%rax,%rcx,8), %rsi
callq 0x41220
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x78(%rax,%rcx,8), %rdx
callq 0x42310
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
movq %rdx, 0x78(%rax,%rcx,8)
cmpq $0x0, -0x30(%rbp)
je 0x422c0
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x42420
movl $0x0, -0x4(%rbp)
jmp 0x422f9
cmpq $0x0, -0x20(%rbp)
jne 0x422d4
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0x422de
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x422e7
movl $0x1, -0x4(%rbp)
jmp 0x422f9
jmp 0x422e9
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x42223
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x3b9e5(%rip), %rax     # 0x7dd10
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x48(%rbp)
cmpq -0x18(%rbp), %rax
jbe 0x4240e
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30340
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4c(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rdi
leaq 0x11d8b(%rip), %rdx     # 0x54128
callq 0x42480
movq %rax, -0x30(%rbp)
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x54(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x58(%rbp), %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x5c(%rbp)
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x41220
jmp 0x42342
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x42563
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30200
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x42550
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x49490
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4256b
jmp 0x42552
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x424a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, -0x3c(%rbp)
subl $0x14, %eax
je 0x42627
jmp 0x425b9
movl -0x3c(%rbp), %eax
subl $0x15, %eax
je 0x425d4
jmp 0x425c3
movl -0x3c(%rbp), %eax
subl $0x16, %eax
je 0x42677
jmp 0x42691
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42580
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42580
jmp 0x426b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x42580
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x419f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42580
jmp 0x426b7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x42580
jmp 0x426b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x42730
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x42709
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x419f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x426d4
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
callq 0x48580
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42f10
cmpq $0x0, -0x18(%rbp)
je 0x42f10
jmp 0x42f2f
leaq 0xb291(%rip), %rdi      # 0x4e1a8
leaq 0x11ffb(%rip), %rsi     # 0x54f19
movl $0x60, %edx
leaq 0x1201f(%rip), %rcx     # 0x54f49
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
cmpl $0x1, (%rax)
jne 0x42f4f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42f8f
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq (%rax), %rdi
movl $0x1d, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x43017
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x15, (%rax)
jne 0x43066
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x41, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x430c5
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x14, (%rax)
jne 0x430b5
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a40
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl $0x41, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x430c3
leaq 0x11ea7(%rip), %rdi     # 0x54f63
movb $0x0, %al
callq 0x1df20
jmp 0x430c5
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop