LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: visit
static Node *
visit(Simp *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], NULL);
	if (ispure(n)) {
		r = n;
	} else {
		if (exprtype(n)->type == Tyvoid) {
			r = NULL;
			append(s, n);
		} else {
			r = temp(s, n);
			append(s, set(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 0x1a014
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
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 0x19fc8
movq -0x10(%rbp), %rdi
callq 0x1adb0
cmpl $0x0, %eax
je 0x1a02c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1a085
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x1, (%rax)
jne 0x1a051
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17710
jmp 0x1a083
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16940
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17580
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x17710
jmp 0x1a085
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: slicebase
static Node *
slicebase(Simp *s, Node *n, Node *off)
{
	Node *u, *v;
	Type *ty;
	int sz;

	u = NULL;
	ty = tybase(exprtype(n));
	switch (ty->type) {
	case Typtr:	u = n;	break;
	case Tyslice:	u = load(addr(s, n, mktyptr(n->loc, base(exprtype(n)))));	break;
	case Tyarray:	u = addr(s, n, base(exprtype(n)));	break;
	default: die("Unslicable type %s", tystr(n->expr.type));
	}
	/* safe: all types we allow here have a sub[0] that we want to grab */
	if (off) {
		off = ptrsized(s, rval(s, off, NULL));
		sz = tysize(n->expr.type->sub[0]);
		v = mul(off, disp(n->loc, sz));
		return add(u, v);
	} else {
		return u;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
subl $0x12, %eax
je 0x1a2eb
jmp 0x1a2d4
movl -0x40(%rbp), %eax
subl $0x14, %eax
je 0x1a2f8
jmp 0x1a2de
movl -0x40(%rbp), %eax
subl $0x15, %eax
je 0x1a34e
jmp 0x1a385
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x1a3a3
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x17790
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x37430
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, %rdi
callq 0x18380
movq %rax, -0x28(%rbp)
jmp 0x1a3a3
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x17790
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x28(%rbp)
jmp 0x1a3a3
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x38a10
movq %rax, %rsi
leaq 0x33fb3(%rip), %rdi     # 0x4e34f
movb $0x0, %al
callq 0x1df20
cmpq $0x0, -0x20(%rbp)
je 0x1a424
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x1a440
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x1c0f0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movl -0x3c(%rbp), %esi
movq (%rax), %rdi
callq 0x17540
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1a690
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x174a0
movq %rax, -0x8(%rbp)
jmp 0x1a42c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: ptrsized
static Node *
ptrsized(Simp *s, Node *v)
{
	if (size(v) == Ptrsz)
		return v;
	else if (size(v) < Ptrsz)
		v = mkexpr(v->loc, Ozwiden, v, NULL);
	else if (size(v) > Ptrsz)
		v = mkexpr(v->loc, Otrunc, v, NULL);
	v->expr.type = tyintptr;
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c480
cmpq $0x8, %rax
jne 0x1a469
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a4e2
movq -0x18(%rbp), %rdi
callq 0x1c480
cmpq $0x8, %rax
jae 0x1a499
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rdi
movl $0x4a, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
jmp 0x1a4c9
movq -0x18(%rbp), %rdi
callq 0x1c480
cmpq $0x8, %rax
jbe 0x1a4c7
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rdi
movl $0x49, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
jmp 0x1a4c9
jmp 0x1a4cb
movq 0x62976(%rip), %rcx     # 0x7ce48
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%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/6/simp.c
// Function: checkidx
static void
checkidx(Simp *s, Op op, Node *len, Node *idx)
{
	Node *cmp, *die, *jmp;
	Node *ok, *fail;

	if (!len)
		return;
	/* create expressions */
	cmp = mkexpr(idx->loc, op, ptrsized(s, idx), ptrsized(s, len), NULL);
	cmp->expr.type = mktype(len->loc, Tybool);
	ok = genlbl(len->loc);
	fail = genlbl(len->loc);
	die = mkexpr(idx->loc, Ocall, abortoob, NULL);
	die->expr.type = mktype(len->loc, Tyvoid);

	/* insert them */
	jmp = mkexpr(idx->loc, Ocjmp, cmp, ok, fail, NULL);
	append(s, jmp);
	append(s, fail);
	append(s, die);
	append(s, ok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1a563
jmp 0x1a686
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a440
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a440
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd00
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x62869(%rip), %rdx     # 0x7ce60
movq (%rax), %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x36c10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq (%rax), %rdi
movl $0x3e, %esi
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x17710
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x17710
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x17710
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x17710
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: intconvert
static Node *
intconvert(Simp *s, Node *from, Type *to, int issigned)
{
	Node *r;
	size_t fromsz, tosz;

	fromsz = size(from);
	tosz = tysize(to);
	r = rval(s, from, NULL);
	if (fromsz > tosz) {
		r = mkexpr(from->loc, Otrunc, r, NULL);
	} else if (tosz > fromsz) {
		if (issigned)
			r = mkexpr(from->loc, Oswiden, r, NULL);
		else
			r = mkexpr(from->loc, Ozwiden, r, NULL);
	}
	r->expr.type = to;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c0f0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x1a7f1
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax), %rdi
movl $0x49, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
jmp 0x1a845
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x1a843
cmpl $0x0, -0x1c(%rbp)
je 0x1a822
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax), %rdi
movl $0x4b, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
jmp 0x1a841
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax), %rdi
movl $0x4a, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x28(%rbp)
jmp 0x1a843
jmp 0x1a845
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: geninitdecl
static Node *
geninitdecl(Node *init, Type *ty, Node **dcl)
{
	Node *n, *d, *r;
	char lbl[128];

	n = mkname(init->loc, genlblstr(lbl, 128, ""));
	d = mkdecl(init->loc, n, ty);
	r = mkexpr(init->loc, Ovar, n, NULL);

	d->decl.init = init;
	d->decl.type = ty;
	d->decl.isconst = 1;
	d->decl.isglobl = 1;

	r->expr.did = d->decl.did;
	r->expr.type = ty;
	r->expr.isconst = 1;
	if (dcl)
		*dcl = d;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x80, %esi
leaq 0x3af90(%rip), %rdx     # 0x55825
callq 0x2fc80
movq %rax, %rsi
movq -0xb8(%rbp), %rax
movq (%rax), %rdi
callq 0x2f540
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq (%rax), %rdi
callq 0x2ff20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rdx
movq (%rax), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x72(%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x71(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x30(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x1a948
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpcode
static Node *
simpcode(Simp *s, Node *fn)
{
	Node *r, *d;

	r = geninitdecl(fn, codetype(exprtype(fn)), &d);
	r->decl.isconst = 1;
	r->decl.isglobl = 1;
	htput(s->globls, d, asmname(d));
	lappend(&file.stmts, &file.nstmts, d);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x76a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x1a860
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x72(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x71(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7720
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movq -0x20(%rbp), %rdx
leaq 0x623b3(%rip), %rsi     # 0x7cd98
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x48, %rsi
callq 0x48290
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: collectenv
static void
collectenv(Simp *s, Node *fn)
{
	size_t nenv, i;
	Node **env;
	size_t off;

	env = getclosure(fn->func.scope, &nenv);
	if (!env)
		return;
	/*
           we need these in a deterministic order so that we can
           put them in the right place both when we use them and
           when we capture them.
         */
	s->hasenv = 1;
	qsort(env, nenv, sizeof(Node*), envcmp);
	off = Ptrsz;    /* we start with the size of the env */
	for (i = 0; i < nenv; i++) {
		off = alignto(off, decltype(env[i]));
		htput(s->envoff, env[i], itop(off));
		off += size(env[i]);
	}
	free(env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x333b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1ae11
jmp 0x1aee4
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
leaq -0x430(%rip), %rcx      # 0x1aa00
callq 0x60b0
movq $0x8, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1aedb
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x16770
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x173e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1c480
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1ae45
movq -0x28(%rbp), %rdi
callq 0x6040
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: isexport
static int
isexport(Node *dcl)
{
	Node *n;

	/* Vishidden should also be exported. */
	if (dcl->decl.vis != Visintern)
		return 1;
	n = dcl->decl.name;
	if (!n->name.ns && streq(n->name.name, "main"))
		return 1;
	if (streq(n->name.name, "__init__") || streq(n->name.name, "__fini__"))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x70(%rax), %eax
cmpl $0x0, %eax
je 0x1b0e2
movl $0x1, -0x4(%rbp)
jmp 0x1b15d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1b11b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x329ba(%rip), %rsi     # 0x4dac2
callq 0x499b0
cmpl $0x0, %eax
je 0x1b11b
movl $0x1, -0x4(%rbp)
jmp 0x1b15d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x326e6(%rip), %rsi     # 0x4d810
callq 0x499b0
cmpl $0x0, %eax
jne 0x1b14d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x326d6(%rip), %rsi     # 0x4d819
callq 0x499b0
cmpl $0x0, %eax
je 0x1b156
movl $0x1, -0x4(%rbp)
jmp 0x1b15d
movl $0x0, -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/6/simp.c
// Function: simp
static Node *
simp(Simp *s, Node *n)
{
	Node *r;

	if (!n)
		return NULL;
	r = NULL;
	switch (n->type) {
	case Nblock:	simpblk(s, n);	break;
	case Ndecl:     declarelocal(s, n);     break;
	case Nexpr:
		if (islbl(n))
			append(s, n);
		else
			r = rval(s, n, NULL);
		if (r)
			append(s, r);
		break;
	default:
		dumpn(n, stderr);
		die("bad node passsed to simp()");
		break;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b214
movq $0x0, -0x8(%rbp)
jmp 0x1b2d0
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x1b241
jmp 0x1b22d
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x1b25f
jmp 0x1b237
movl -0x24(%rbp), %eax
subl $0xb, %eax
je 0x1b250
jmp 0x1b2a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b2e0
jmp 0x1b2c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17210
jmp 0x1b2c8
movq -0x18(%rbp), %rdi
callq 0x1b360
cmpl $0x0, %eax
je 0x1b27c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17710
jmp 0x1b291
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1b2a5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17710
jmp 0x1b2c8
movq -0x18(%rbp), %rdi
movq 0x43d3e(%rip), %rax     # 0x5eff0
movq (%rax), %rsi
callq 0x1de90
leaq 0x331f9(%rip), %rdi     # 0x4e4ba
movb $0x0, %al
callq 0x1df20
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpblk
static void
simpblk(Simp *s, Node *n)
{
	size_t i;

	for (i = 0; i < n->block.nstmts; i++) {
		n->block.stmts[i] = fold(n->block.stmts[i], 0);
		simp(s, n->block.stmts[i]);
	}
}

// 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 -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x1b357
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x1f390
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1b1f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1b2f8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: islbl
static int
islbl(Node *n)
{
	Node *l;
	if (exprop(n) != Olit)
		return 0;
	l = n->expr.args[0];
	return l->type == Nlit && l->lit.littype == Llbl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0x1b383
movl $0x0, -0x4(%rbp)
jmp 0x1b3ba
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x9, 0x8(%rcx)
movb %al, -0x19(%rbp)
jne 0x1b3af
movq -0x18(%rbp), %rax
cmpl $0x6, 0x18(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %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/6/simp.c
// Function: extractsub
static void
extractsub(Simp *s, Node *e)
{
	size_t i;
	Node *sub;

	assert(e != NULL);
	switch (exprop(e)) {
	case Oslice:
		sub = e->expr.args[0];
		extractsub(s, sub);
		if (exprop(sub) == Oarr) {
			if (sub->expr.nargs > 0) {
				e->expr.args[0] = simpblob(s, e->expr.args[0]);
			} else  {
				e->expr.args[0] = mkintlit(e->loc, 0);
				e->expr.args[0]->expr.type = tyintptr;
			}
		}
		break;
	case Oarr:
	case Ostruct:
		for (i = 0; i < e->expr.nargs; i++)
			extractsub(s, e->expr.args[i]);
		break;
	case Oucon:
		if (e->expr.nargs == 2)
			extractsub(s, e->expr.args[1]);
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b3e9
jmp 0x1b408
leaq 0x33125(%rip), %rdi     # 0x4e515
leaq 0x32ce9(%rip), %rsi     # 0x4e0e0
movl $0x60c, %edx            # imm = 0x60C
leaq 0x3311c(%rip), %rcx     # 0x4e51f
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x29, %eax
je 0x1b43f
jmp 0x1b41d
movl -0x24(%rbp), %eax
subl $0x36, %eax
je 0x1b50f
jmp 0x1b42b
movl -0x24(%rbp), %eax
addl $-0x38, %eax
subl $0x2, %eax
jb 0x1b4d0
jmp 0x1b531
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b3d0
movq -0x20(%rbp), %rdi
callq 0x2f210
cmpl $0x39, %eax
jne 0x1b4ce
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jbe 0x1b498
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x19440
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
jmp 0x1b4cc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f3c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq 0x6198b(%rip), %rcx     # 0x7ce48
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x1b4ce
jmp 0x1b533
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x1b50d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1b3d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1b4d8
jmp 0x1b533
movq -0x10(%rbp), %rax
cmpq $0x2, 0x40(%rax)
jne 0x1b52f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x1b3d0
jmp 0x1b533
jmp 0x1b533
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: blobsz
size_t
blobsz(Blob *b)
{
	size_t n;
	size_t i;

	switch (b->type) {
	case Bti8:	return 1;	break;
	case Bti16:	return 2;	break;
	case Bti32:	return 4;	break;
	case Bti64:	return 8;	break;
	case Btref:	return 8;	break;
	case Btbytes:	return b->bytes.len;	break;
	case Btimin:
		if (b->ival >= 1ULL << 56)
			die("packed int too big");

		for (i = 1; i < 8; i++)
			if (b->ival < 1ULL << (7*i))
				return i;
		die("impossible blob size");
		break;
	case Btseq:
		n = 0;
		for (i = 0; i < b->seq.nsub; i++)
			n += blobsz(b->seq.sub[i]);
		return n;
		break;
	default:
			die("unknown blob type");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0x1b68f
movq -0x28(%rbp), %rax
leaq 0x32fd5(%rip), %rcx     # 0x4e540
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rbp)
jmp 0x1b69d
movq $0x2, -0x8(%rbp)
jmp 0x1b69d
movq $0x4, -0x8(%rbp)
jmp 0x1b69d
movq $0x8, -0x8(%rbp)
jmp 0x1b69d
movq $0x8, -0x8(%rbp)
jmp 0x1b69d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b69d
movq -0x10(%rbp), %rax
movabsq $0x100000000000000, %rcx # imm = 0x100000000000000
cmpq %rcx, 0x20(%rax)
jb 0x1b5e8
leaq 0x33113(%rip), %rdi     # 0x4e6f4
movb $0x0, %al
callq 0x1df20
movq $0x1, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x1b62e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
imulq $0x7, -0x20(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1b61e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b69d
jmp 0x1b620
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b5f0
leaq 0x330d2(%rip), %rdi     # 0x4e707
movb $0x0, %al
callq 0x1df20
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x1b685
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1b540
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b64c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b69d
leaq 0x33086(%rip), %rdi     # 0x4e71c
movb $0x0, %al
callq 0x1df20
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: namevec
void
namevec(Blob ***sub, size_t *nsub, Node *n)
{
	char *buf;
	size_t len;

	if (n->name.ns) {
		len = strlen(n->name.name) + strlen(n->name.ns) + 1;
		buf = xalloc(len + 1);
		bprintf(buf, len + 1, "%s.%s", n->name.ns, n->name.name);
	} else {
		len = strlen(n->name.name);
		buf = xalloc(len + 1);
		bprintf(buf, len + 1, "%s", n->name.name);
	}
	lappend(sub, nsub, mkblobi(Btimin, len));
	lappend(sub, nsub, mkblobbytes(buf, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1b73c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6100
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6100
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %r8
leaq 0x36d13(%rip), %rdx     # 0x52446
movb $0x0, %al
callq 0x4a230
jmp 0x1b780
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x481b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x37322(%rip), %rdx     # 0x52a9b
movb $0x0, %al
callq 0x4a230
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rsi
movl $0x4, %edi
callq 0x6480
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x48290
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6500
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x48290
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: unionmemb
static void
unionmemb(Blob ***sub, size_t *nsub, Ucon *ucon)
{
	namevec(sub, nsub, ucon->name);
	if (ucon->etype) {
		lappend(sub, nsub, tydescsub(ucon->etype));
	} else  {
		lappend(sub, nsub, mkblobi(Btimin, 1));
		lappend(sub, nsub, mkblobi(Bti8, Tybad));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x1b6b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1bea3
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1b7f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x48290
jmp 0x1befd
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x4, %edi
movl $0x1, %esi
callq 0x6480
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x48290
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x48290
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: namedesc
Blob *
namedesc(Type *ty)
{
	Blob **sub;
	size_t nsub;

	sub = NULL;
	nsub = 0;
	lappend(&sub, &nsub, mkblobi(Bti8, Tyname));
	namevec(&sub, &nsub, ty->name);
	lappend(&sub, &nsub, tydescsub(ty->sub[0]));
	return mkblobseq(sub, nsub);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %edi, %edi
movl $0x1c, %esi
callq 0x6480
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48290
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1b6b0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x1b7f0
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x48290
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6550
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: tydescblob
Blob *
tydescblob(Type *ty)
{
	char buf[512];
	Blob *b, *sz, *sub;

	if (ty->type == Tyname && hasparams(ty))
		return NULL;

	if (ty->type == Tyname) {
		b = mkblobseq(NULL, 0);
		sz = mkblobi(Btimin, 0);
		sub = namedesc(ty);
		sz->ival = blobsz(sub);
		lappend(&b->seq.sub, &b->seq.nsub, sz);
		lappend(&b->seq.sub, &b->seq.nsub, sub);
		if (ty->vis != Visintern)
			b->isglobl = 1;
	} else {
		b = tydescsub(ty);
	}
	tydescid(buf, sizeof buf, ty);
	b->lbl = strdup(buf);
	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x1bfd3
movq -0x10(%rbp), %rdi
callq 0x37ce0
cmpl $0x0, %eax
je 0x1bfd3
movq $0x0, -0x8(%rbp)
jmp 0x1c0df
movq -0x10(%rbp), %rax
cmpl $0x1c, (%rax)
jne 0x1c095
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x6550
movq %rax, -0x218(%rbp)
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movq %rax, -0x220(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bf10
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
callq 0x1b540
movq %rax, %rcx
movq -0x220(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x218(%rbp), %rdi
addq $0x20, %rdi
addq $0x8, %rdi
movq -0x218(%rbp), %rsi
addq $0x20, %rsi
movq -0x220(%rbp), %rdx
callq 0x48290
movq -0x218(%rbp), %rdi
addq $0x20, %rdi
addq $0x8, %rdi
movq -0x218(%rbp), %rsi
addq $0x20, %rsi
movq -0x228(%rbp), %rdx
callq 0x48290
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1c093
movq -0x218(%rbp), %rax
movb $0x1, 0x18(%rax)
jmp 0x1c0a5
movq -0x10(%rbp), %rdi
callq 0x1b7f0
movq %rax, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x7b70
leaq -0x210(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x218(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x218(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: size
size_t
size(Node *n)
{
	Type *t;

	if (n->type == Nexpr)
		t = n->expr.type;
	else
		t = n->decl.type;
	return tysize(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x1c4a4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1c4b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c0f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: tyalign
size_t
tyalign(Type *ty)
{
	size_t align, i;

	align = 1;
	ty = tybase(ty);
	switch (ty->type) {
	case Tyarray:
		align = tyalign(ty->sub[0]);
		break;
	case Tytuple:
		for (i = 0; i < ty->nsub; i++)
			align = max(align, tyalign(ty->sub[i]));
		break;
	case Tyunion:
		align = 4;
		for (i = 0; i < ty->nmemb; i++)
			if (ty->udecls[i]->etype)
				align = max(align, tyalign(ty->udecls[i]->etype));
		break;
	case Tystruct:
		for (i = 0; i < ty->nmemb; i++)
			align = max(align, tyalign(decltype(ty->sdecls[i])));
		break;
	case Tyslice:
		align = 8;
		break;
	default:
		align = max(align, tysize(ty));
	}
	return min(align, Ptrsz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x36a30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x14, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x1c665
movq -0x20(%rbp), %rax
leaq 0x3215c(%rip), %rcx     # 0x4e660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x1c4c0
movq %rax, -0x10(%rbp)
jmp 0x1c686
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x1c577
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1c4c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4a550
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c52e
jmp 0x1c686
movq $0x4, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x1c5f8
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x28(%rax)
je 0x1c5e8
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
callq 0x1c4c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4a550
movq %rax, -0x10(%rbp)
jmp 0x1c5ea
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c58c
jmp 0x1c686
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x1c659
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x1c4c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4a550
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1c605
jmp 0x1c686
movq $0x8, -0x10(%rbp)
jmp 0x1c686
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4a550
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x4a580
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: countargs
size_t
countargs(Type *t)
{
	size_t nargs;

	t = tybase(t);
	nargs = t->nsub - 1;
	if (classify(t->sub[0]) == ArgBig)
		nargs++;
	/* valists are replaced with hidden type parameter,
	 * which we want on the stack for ease of ABI */
	if (tybase(t->sub[t->nsub - 1])->type == Tyvalist)
		nargs--;
	return nargs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x36a30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x1c9b0
cmpl $0x8, %eax
jne 0x1c96a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x70(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36a30
cmpl $0x11, (%rax)
jne 0x1c998
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: classify
ArgType
classify(Type *t)
{
	size_t sz = tysize(t);
	size_t total_offset = 0;

	/* p must be of length exactly 2 */
	PassIn pi[2] = { PassInNoPref, PassInNoPref };

	if (tybase(t)->type == Tyvoid) {
		return ArgVoid;
	} else if (isstacktype(t)) {
		if (isaggregate(t) && sz <= 16) {
			classify_recursive(t, pi, &total_offset);
			if (pi[0] == PassInMemory || pi[1] == PassInMemory) {
				return ArgBig;
			}

			switch(pi[0]) {
			case PassInInt:
				if (sz <= 8) {
					return ArgAggrI;
				}
				switch(pi[1]) {
				case PassInInt: return ArgAggrII;
				case PassInSSE: return ArgAggrIF;
				default:
					die("Impossible return from classify_recursive");
					break;
				}
				break;
			case PassInSSE:
				if (sz <= 8) {
					return ArgAggrF;
				}
				switch(pi[1]) {
				case PassInInt: return ArgAggrFI;
				case PassInSSE: return ArgAggrFF;
				default:
					die("Impossible return from classify_recursive");
					break;
				}
				break;
			default:
				die("Impossible return from classify_recursive");
				break;
			}
		}

		return ArgBig;
	}

	return ArgReg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c0f0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x6180
movq -0x10(%rbp), %rdi
callq 0x36a30
cmpl $0x1, (%rax)
jne 0x1c9fb
movl $0x0, -0x4(%rbp)
jmp 0x1cb1f
movq -0x10(%rbp), %rdi
callq 0x369d0
cmpl $0x0, %eax
je 0x1cb16
movq -0x10(%rbp), %rdi
callq 0x1cb30
cmpl $0x0, %eax
je 0x1cb0d
cmpq $0x10, -0x18(%rbp)
ja 0x1cb0d
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1cbb0
cmpl $0x3, -0x28(%rbp)
je 0x1ca47
cmpl $0x3, -0x24(%rbp)
jne 0x1ca53
movl $0x8, -0x4(%rbp)
jmp 0x1cb1f
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x1cab8
jmp 0x1ca60
movl -0x2c(%rbp), %eax
subl $0x2, %eax
jne 0x1caff
jmp 0x1ca6e
cmpq $0x8, -0x18(%rbp)
ja 0x1ca81
movl $0x2, -0x4(%rbp)
jmp 0x1cb1f
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x1, %eax
je 0x1caa1
jmp 0x1ca8e
movl -0x30(%rbp), %eax
subl $0x2, %eax
jne 0x1caaa
jmp 0x1ca98
movl $0x4, -0x4(%rbp)
jmp 0x1cb1f
movl $0x6, -0x4(%rbp)
jmp 0x1cb1f
leaq 0x31e05(%rip), %rdi     # 0x4e8b6
movb $0x0, %al
callq 0x1df20
cmpq $0x8, -0x18(%rbp)
ja 0x1cac8
movl $0x3, -0x4(%rbp)
jmp 0x1cb1f
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x1cae8
jmp 0x1cad5
movl -0x34(%rbp), %eax
subl $0x2, %eax
jne 0x1caf1
jmp 0x1cadf
movl $0x5, -0x4(%rbp)
jmp 0x1cb1f
movl $0x7, -0x4(%rbp)
jmp 0x1cb1f
leaq 0x31dbe(%rip), %rdi     # 0x4e8b6
movb $0x0, %al
callq 0x1df20
leaq 0x31db0(%rip), %rdi     # 0x4e8b6
movb $0x0, %al
callq 0x1df20
movl $0x8, -0x4(%rbp)
jmp 0x1cb1f
jmp 0x1cb18
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/typeinfo.c
// Function: join_classification
static void join_classification(PassIn *current, PassIn new)
{
	if (*current == PassInNoPref) {
		*current = new;
	} else if ((*current == PassInInt) || (new == PassInInt)) {
		*current = PassInInt;
	} else if (*current != new) {
		*current = PassInMemory;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1cf2f
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1cf63
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
je 0x1cf3e
cmpl $0x2, -0xc(%rbp)
jne 0x1cf4a
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x1cf61
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x1cf5f
movq -0x8(%rbp), %rax
movl $0x3, (%rax)
jmp 0x1cf61
jmp 0x1cf63
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/dump.c
// Function: outsym
static void
outsym(Node *s, FILE *fd, int depth)
{
	char buf[1024];

	if (s->decl.isconst)
		findentf(fd, depth, "const ");
	else
		findentf(fd, depth, "var ");
	outname(s->decl.name, fd);
	fprintf(fd, " : %s\n", tyfmt(buf, 1024, s->decl.type));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x72(%rax)
je 0x1cfd7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x319c3(%rip), %rdx     # 0x4e991
movb $0x0, %al
callq 0x4a710
jmp 0x1cfec
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq 0x319b3(%rip), %rdx     # 0x4e998
movb $0x0, %al
callq 0x4a710
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dec0
movq -0x10(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x37e90
movq -0x428(%rbp), %rdi
movq %rax, %rdx
leaq 0x3196b(%rip), %rsi     # 0x4e99d
movb $0x0, %al
callq 0x6230
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/dump.c
// Function: outenv
static void
outenv(Tyenv *e, FILE *fd, int depth)
{
	size_t n, i;
	void **k;
	Type *t;
	char *s;

	k = htkeys(e->tab, &n);
	for (i = 0; i < n; i++) {
		t = htget(e->tab, k[i]);
		s = tystr(t);
		findentf(fd, depth + 1, "B %s\n", s);
		free(s);
	}
	free(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x49720
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1d397
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x38a10
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x40(%rbp), %rcx
leaq 0x31669(%rip), %rdx     # 0x4e9e2
movb $0x0, %al
callq 0x4a710
movq -0x40(%rbp), %rdi
callq 0x6040
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d330
movq -0x30(%rbp), %rdi
callq 0x6040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/dump.c
// Function: dumpfilestabs
void
dumpfilestabs(int depth, FILE *fd)
{
	size_t nk, i;
	void **k;

	k = htkeys(file.ns, &nk);
	for (i = 0; i < nk; i++)
		outstab(htget(file.ns, k[i]), fd, depth);
	free(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x5f9d2(%rip), %rax     # 0x7cd98
movq 0xa0(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x49720
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1d428
leaq 0x5f9a5(%rip), %rax     # 0x7cd98
movq 0xa0(%rax), %rdi
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x49490
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x4(%rbp), %edx
callq 0x1d080
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1d3e2
movq -0x28(%rbp), %rdi
callq 0x6040
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/dump.c
// Function: dump
void
dump(FILE *fd)
{
	size_t i;

	fprintf(fd, "(name = %s)\n", file.files[0]);
	dumpfilestabs(1, fd);
	for (i = 0; i < file.nuses; i++)
		outnode(file.uses[i], fd, 1);
	for (i = 0; i < file.nstmts; i++)
		outnode(file.stmts[i], fd, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5f941(%rip), %rax     # 0x7cd98
movq 0x8(%rax), %rax
movq (%rax), %rdx
leaq 0x3151f(%rip), %rsi     # 0x4e984
movb $0x0, %al
callq 0x6230
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x1d3b0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x5f90b(%rip), %rcx     # 0x7cd98
cmpq 0x18(%rcx), %rax
jae 0x1d4c2
leaq 0x5f8fe(%rip), %rax     # 0x7cd98
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x1d510
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d482
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x5f8c3(%rip), %rcx     # 0x7cd98
cmpq 0x48(%rcx), %rax
jae 0x1d50a
leaq 0x5f8b6(%rip), %rax     # 0x7cd98
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x1d510
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d4ca
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/err.c
// Function: die
void
die(char *msg, ...)
{
	va_list ap;

	va_start(ap, msg);
	vfprintf(stderr, msg, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1df55
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x41049(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x62f0
movq 0x41032(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq 0x2fbee(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
leaq -0x20(%rbp), %rax
callq 0x6050
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/err.c
// Function: lfatalv
void
lfatalv(Srcloc l, char *msg, va_list ap)
{
	fprintf(stdout, "%s:%d: ", fname(l), lnum(l));
	vfprintf(stdout, msg, ap);
	fprintf(stdout, "\n");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x40f35(%rip), %rax     # 0x5efd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f0b0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl %eax, %ecx
leaq 0x30ac7(%rip), %rsi     # 0x4eb90
movb $0x0, %al
callq 0x6230
movq 0x40ef9(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x62f0
movq 0x40ee2(%rip), %rax     # 0x5efd0
movq (%rax), %rdi
leaq 0x2fabe(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
movl $0x1, %edi
callq 0x6310
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/export.c
// Function: tagreflect
void
tagreflect(Type *t)
{
	size_t i;

	if (hasparams(t) || t->isreflect)
		return;

	t->isreflect = 1;
	for (i = 0; i < t->nsub; i++)
		tagreflect(t->sub[i]);
	switch (t->type) {
	case Tystruct:
		for (i = 0; i < t->nmemb; i++)
			tagreflect(decltype(t->sdecls[i]));
		break;
	case Tyunion:
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype)
				tagreflect(t->udecls[i]->etype);
		break;
	case Tyname:
		for (i = 0; i < t->narg; i++)
			tagreflect(t->arg[i]);
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37ce0
cmpl $0x0, %eax
jne 0x1e1da
movq -0x8(%rbp), %rax
movsbl 0x95(%rax), %eax
cmpl $0x0, %eax
je 0x1e1df
jmp 0x1e332
movq -0x8(%rbp), %rax
movb $0x1, 0x95(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x1e223
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1e1b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e1f2
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x17, %eax
je 0x1e24e
jmp 0x1e233
movl -0x14(%rbp), %eax
subl $0x18, %eax
je 0x1e297
jmp 0x1e23d
movl -0x14(%rbp), %eax
subl $0x1c, %eax
je 0x1e2f5
jmp 0x1e330
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x1e292
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30260
movq %rax, %rdi
callq 0x1e1b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e256
jmp 0x1e332
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x1e2f3
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x28(%rax)
je 0x1e2e3
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x28(%rax), %rdi
callq 0x1e1b0
jmp 0x1e2e5
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e29f
jmp 0x1e332
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x1e32e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1e1b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e2fd
jmp 0x1e330
jmp 0x1e332
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)