LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: declarelocal
static void
declarelocal(Simp *s, Node *n)
{
	if (n->type == Nexpr)
		n = decls[n->decl.did];
	if (n->decl.isconst && n->decl.isextern)
		htput(s->globls, n, asmname(n));
	else if (stacknode(n))
		forcelocal(s, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, 0x8(%rsi)
jne 0xf7e4
leaq 0x5218f(%rip), %rax     # 0x61968
movq (%rax), %rax
movq 0x18(%rbx), %rcx
movq (%rax,%rcx,8), %rbx
cmpb $0x0, 0x72(%rbx)
je 0xf811
cmpb $0x0, 0x74(%rbx)
je 0xf811
movq 0x40(%r14), %r14
movq %rbx, %rdi
callq 0x5630
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2dbc2
movq %rbx, %rdi
callq 0xee80
testl %eax, %eax
je 0xf82c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf834
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: forcelocal
static void
forcelocal(Simp *s, Node *n)
{
	assert(n->type == Ndecl || (n->type == Nexpr && exprop(n) == Ovar));
	s->stksz += size(n);
	s->stksz = align(s->stksz, min(size(n), Ptrsz));
	if (debugopt['i']) {
		dumpn(n, stdout);
		printf("declared at %zd, size = %zd\n", s->stksz, size(n));
	}
	htput(s->stkoff, n, itop(s->stksz));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
cmpl $0xb, %eax
je 0xf861
cmpl $0x8, %eax
jne 0xf8ec
movq %rbx, %rdi
callq 0x1d672
cmpl $0x33, %eax
jne 0xf8ec
movq %rbx, %rdi
callq 0x1281a
movq %rax, %r15
addq 0x58(%r14), %r15
movq %r15, 0x58(%r14)
movq %rbx, %rdi
callq 0x1281a
movl $0x8, %esi
movq %rax, %rdi
callq 0x2e68c
movq %r15, %rdi
movq %rax, %rsi
callq 0x2e697
movq %rax, 0x58(%r14)
leaq 0x51941(%rip), %rax     # 0x611e0
cmpb $0x0, 0x69(%rax)
je 0xf8d7
movq 0x34724(%rip), %rax     # 0x43fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x139c1
movq 0x58(%r14), %r15
movq %rbx, %rdi
callq 0x1281a
leaq 0x22a88(%rip), %rdi     # 0x32352
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4140
movq 0x48(%r14), %rdi
movq 0x58(%r14), %rdx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2dbc2
leaq 0x22a03(%rip), %rdi     # 0x322f6
leaq 0x229da(%rip), %rsi     # 0x322d4
leaq 0x22a31(%rip), %rcx     # 0x32332
movl $0xab, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: add
static Node *
add(Node *a, Node *b)
{
	Node *n;

	assert(size(a) == size(b));
	n = mkexpr(a->loc, Oadd, a, b, NULL);
	n->expr.type = a->expr.type;
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1281a
movq %rax, %r15
movq %r14, %rdi
callq 0x1281a
cmpq %rax, %r15
jne 0xf951
movq (%rbx), %rdi
movl $0x2, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x22a17(%rip), %rdi     # 0x3236f
leaq 0x22975(%rip), %rsi     # 0x322d4
leaq 0x22a1c(%rip), %rcx     # 0x32382
movl $0x69, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: set
static Node *
set(Node *a, Node *b)
{
	Node *n;

	assert(a != NULL && b != NULL);
	assert(exprop(a) == Ovar || exprop(a) == Oderef);
	if (tybase(exprtype(a))->type == Tyvoid)
		return a;

	n = mkexpr(a->loc, Oset, a, b, NULL);
	n->expr.type = exprtype(a);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf9e5
movq %rsi, %r14
testq %rsi, %rsi
je 0xf9e5
movq %rdi, %rbx
callq 0x1d672
cmpl $0x33, %eax
je 0xf99b
movq %rbx, %rdi
callq 0x1d672
cmpl $0x13, %eax
jne 0xfa04
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
cmpl $0x1, (%rax)
je 0xf9da
movq (%rbx), %rdi
movl $0x40, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, 0x20(%r14)
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x229b0(%rip), %rdi     # 0x3239c
leaq 0x228e1(%rip), %rsi     # 0x322d4
leaq 0x229b9(%rip), %rcx     # 0x323b3
movl $0xef, %edx
callq 0x4180
leaq 0x229c2(%rip), %rdi     # 0x323cd
leaq 0x228c2(%rip), %rsi     # 0x322d4
leaq 0x2299a(%rip), %rcx     # 0x323b3
movl $0xf0, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: deref
static Node *
deref(Node *a, Type *t)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	if (t)
		n->expr.type = t;
	else
		n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0xfa6d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x13, %esi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
testq %rbx, %rbx
jne 0xfa61
movq 0x20(%r14), %rcx
cmpq $0x1, 0x70(%rcx)
jne 0xfa8c
movq 0x68(%rcx), %rcx
movq (%rcx), %rbx
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22982(%rip), %rdi     # 0x323f6
leaq 0x22859(%rip), %rsi     # 0x322d4
leaq 0x22990(%rip), %rcx     # 0x32412
movl $0xe1, %edx
callq 0x4180
leaq 0x2299b(%rip), %rdi     # 0x3242e
leaq 0x2283a(%rip), %rsi     # 0x322d4
leaq 0x2299a(%rip), %rcx     # 0x3243b
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: append
static void
append(Simp *s, Node *n)
{
	if (debugopt['S'])
		dumpn(n, stdout);
        assert(n->type != Ndecl);
	lappend(&s->stmts, &s->nstmts, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x51724(%rip), %rax     # 0x611e0
cmpb $0x0, 0x53(%rax)
je 0xfad4
movq 0x34507(%rip), %rax     # 0x43fd0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x139c1
cmpl $0xb, 0x8(%rbx)
je 0xfaf4
leaq 0x8(%r14), %rdi
addq $0x10, %r14
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d3ff
leaq 0x22953(%rip), %rdi     # 0x3244e
leaq 0x227d2(%rip), %rsi     # 0x322d4
leaq 0x22956(%rip), %rcx     # 0x3245f
movl $0x4d, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: load
static Node *
load(Node *a)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rax
cmpl $0x12, (%rax)
jne 0x10bfc
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x13, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq 0x20(%rbx), %rcx
cmpq $0x1, 0x70(%rcx)
jne 0x10c1b
movq 0x68(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
popq %rbx
retq
leaq 0x217f3(%rip), %rdi     # 0x323f6
leaq 0x216ca(%rip), %rsi     # 0x322d4
leaq 0x21a2c(%rip), %rcx     # 0x3263d
movl $0xd6, %edx
callq 0x4180
leaq 0x2180c(%rip), %rdi     # 0x3242e
leaq 0x216ab(%rip), %rsi     # 0x322d4
leaq 0x2180b(%rip), %rcx     # 0x3243b
movl $0x60, %edx
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: idxaddr
static Node *
idxaddr(Simp *s, Node *seq, Node *idx)
{
	Node *a, *t, *u, *v, *w; /* temps */
	Node *r; /* result */
	Type *ty, *seqty;
	size_t sz;

	a = rval(s, seq, NULL);
	seqty = tybase(exprtype(seq));
	ty = seqty->sub[0];
	if (seqty->type == Tyarray) {
		t = addr(s, a, ty);
		w = seqty->asize;
	} else if (seqty->type == Tyslice) {
		t = load(addr(s, a, mktyptr(seq->loc, ty)));
		w = slicelen(s, a);
	} else {
		die("can't index type %s", tystr(seq->expr.type));
	}
	assert(exprtype(t)->type == Typtr);
	u = rval(s, idx, NULL);
	u = ptrsized(s, u);
	checkidx(s, Olt, w, u);
	sz = tysize(ty);
	v = mul(u, disp(seq->loc, sz));
	r = add(t, v);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xfb13
movq %rax, %rbp
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
movq %rax, %r15
movq 0x68(%rax), %rax
movq (%rax), %r12
movl (%r15), %eax
cmpl $0x14, %eax
je 0x10cce
cmpl $0x15, %eax
jne 0x10db2
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xf094
movq %rax, %r13
movq 0x88(%r15), %rbp
jmp 0x10d00
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x231bc
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xf094
movq %rax, %rdi
callq 0x10bc3
movq %rax, %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1187b
movq %rax, %rbp
movq %r13, %rdi
callq 0x1e5d4
cmpl $0x12, (%rax)
jne 0x10d93
movq %r14, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xfb13
movq %rax, %rdi
callq 0x1172b
movq %rax, %r15
movq %r14, %rdi
movl $0x1b, %esi
movq %rbp, %rdx
movq %rax, %rcx
callq 0x11782
movq %r12, %rdi
callq 0x125dd
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d7ca
movq 0x505d2(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%r15), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq 0x20(%r15), %rcx
movq %rcx, 0x20(%rax)
movq %r13, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf90b
leaq 0x217d0(%rip), %rdi     # 0x3256a
leaq 0x21533(%rip), %rsi     # 0x322d4
leaq 0x217dd(%rip), %rcx     # 0x32585
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x4180
movq 0x20(%rbx), %rdi
callq 0x23e44
leaq 0x21794(%rip), %rdi     # 0x32556
movq %rax, %rsi
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: seqlen
static Node *
seqlen(Simp *s, Node *n, Type *ty)
{
	Node *t, *r;

        r = NULL;
	if (exprtype(n)->type == Tyslice) {
		t = slicelen(s, n);
		r = simpcast(s, t, ty);
	} else if (exprtype(n)->type == Tyarray) {
		t = exprtype(n)->asize;
                if (t)
                    r = simpcast(s, t, ty);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e5d4
cmpl $0x14, (%rax)
jne 0x10dfa
movq %r14, %rdi
movq %r15, %rsi
callq 0x1187b
movq %r14, %rdi
movq %rax, %rsi
jmp 0x10e1e
movq %r15, %rdi
callq 0x1e5d4
cmpl $0x15, (%rax)
jne 0x10e28
movq %r15, %rdi
callq 0x1e5d4
movq 0x88(%rax), %rsi
testq %rsi, %rsi
je 0x10e28
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10e30
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: simpblob
static Node *
simpblob(Simp *s, Node *blob)
{
	Node *r, *d;

	r = geninitdecl(blob, exprtype(blob), &d);
	htput(s->globls, d, asmname(d));
	lappend(&s->blobs, &s->nblobs, d);
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e5d4
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1192a
movq %rax, %r14
movq 0x40(%rbx), %r12
movq (%r15), %r13
movq %r13, %rdi
callq 0x5630
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2dbc2
leaq 0x30(%rbx), %rdi
addq $0x38, %rbx
movq (%r15), %rdx
movq %rbx, %rsi
callq 0x2d3ff
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: assign
static Node *
assign(Simp *s, Node *lhs, Node *rhs)
{
	Node *t, *u, *v, *r;

	t = lval(s, lhs);
	u = rval(s, rhs, t);

	if (tybase(exprtype(lhs))->type == Tyvoid)
		return u;

	/* hack: we're assigning to lhs, but blitting shit over doesn't
	 * trigger that */
	if (stacknode(lhs))
		def(s, lhs);
	/* if we stored the result into t, rval() should return that,
	 * so we know our work is done. */
	if (u == t) {
		r = t;
	} else if (stacknode(lhs)) {
		t = addr(s, t, exprtype(lhs));
		u = addr(s, u, exprtype(lhs));
		v = disp(lhs->loc, size(lhs));
		r = mkexpr(lhs->loc, Oblit, t, u, v, NULL);
		r->expr.type = exprtype(lhs);
	} else {
		r = set(t, u);
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1144e
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xfb13
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
cmpl $0x1, (%rax)
je 0x11429
movq %rbx, %rdi
callq 0xee80
testl %eax, %eax
je 0x11392
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11a51
cmpq %r12, %r14
je 0x11426
movq %rbx, %rdi
callq 0xee80
testl %eax, %eax
je 0x11438
movq %rbx, %rdi
callq 0x1e5d4
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xf094
movq %rax, %r12
movq %rbx, %rdi
callq 0x1e5d4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf094
movq %rax, %r14
movq %rbx, %rdi
callq 0x1281a
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d7ca
movq 0x4ff32(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%rbx), %rdi
movl $0x46, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e5d4
movq %rax, 0x20(%r14)
jmp 0x11429
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf970
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: lval
static Node *
lval(Simp *s, Node *n)
{
	Node *r;
	Node **args;

	args = n->expr.args;
	switch (exprop(n)) {
	case Ovar:	r = loadvar(s, n, NULL);	break;
	case Oidx:	r = loadidx(s, args[0], args[1]);	break;
	case Oderef:	r = deref(rval(s, args[0], NULL), NULL);	break;
	case Otupmemb:	r = rval(s, n, NULL);	break;
	case Omemb:	r = rval(s, n, NULL);	break;
	case Ostruct:	r = rval(s, n, NULL);	break;
	case Oucon:	r = rval(s, n, NULL);	break;
	case Oarr:	r = rval(s, n, NULL);	break;

	/*
	  not expressible as lvalues in syntax, but
	  we take their address in matches
	 */
	case Oudata:    r = rval(s, n, NULL); break;
	case Outag:     r = rval(s, n, NULL); break;
	case Otupget:   r = rval(s, n, NULL); break;

	default:
			fatal(n, "%s cannot be an lvalue", opstr[exprop(n)]);
			break;
	}
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %r15
movq %rsi, %rdi
callq 0x1d672
cmpl $0x32, %eax
jle 0x1149d
cmpl $0x42, %eax
jg 0x114cd
addl $-0x33, %eax
cmpl $0x6, %eax
ja 0x11516
leaq 0x20e36(%rip), %rcx     # 0x322b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xeea6
cmpl $0x29, %eax
jg 0x114de
cmpl $0x13, %eax
je 0x114fa
cmpl $0x28, %eax
jne 0x11516
movq (%r15), %rsi
movq 0x8(%r15), %rbx
movq %r14, %rdi
xorl %edx, %edx
callq 0xfb13
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x10c6a
jmp 0x11507
cmpl $0x43, %eax
je 0x114e8
cmpl $0x44, %eax
je 0x114e8
cmpl $0x45, %eax
je 0x114e8
jmp 0x11516
cmpl $0x2a, %eax
je 0x114e8
cmpl $0x2b, %eax
jne 0x11516
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0xfb13
movq (%r15), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xfb13
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xfa23
movq %rbx, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x4ee79(%rip), %rcx     # 0x603a0
movq (%rcx,%rax,8), %rdx
leaq 0x210f4(%rip), %rsi     # 0x32626
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13aa3
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x40(%rsi)
je 0x11574
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xfb13
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x11551
movq %rbx, %rdi
callq 0x1d672
movl %eax, %eax
leaq 0x4f41b(%rip), %rcx     # 0x609a0
cmpl $0x0, (%rcx,%rax,4)
jne 0x115c7
movq %rbx, %rdi
callq 0x1e5d4
cmpl $0x1, (%rax)
jne 0x1159d
xorl %r15d, %r15d
jmp 0x115b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0xef46
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf970
movq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfaab
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x22c44
movl (%rax), %eax
movq %rbx, %r12
cmpl $0x12, %eax
je 0x1166b
cmpl $0x15, %eax
je 0x11643
cmpl $0x14, %eax
jne 0x11711
movq %rbx, %rdi
callq 0x1e5d4
cmpq $0x1, 0x70(%rax)
jne 0x116f2
movq 0x68(%rax), %rax
movq (%rax), %rsi
movq (%rbx), %rdi
callq 0x231bc
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf094
movq %rax, %rdi
callq 0x10bc3
jmp 0x11668
movq %rbx, %rdi
callq 0x1e5d4
cmpq $0x1, 0x70(%rax)
jne 0x116f2
movq 0x68(%rax), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf094
movq %rax, %r12
testq %r14, %r14
je 0x116e3
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xfb13
movq %rax, %rdi
callq 0x1172b
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x68(%rax), %rax
movq (%rax), %rdi
callq 0x125dd
movq (%rbx), %rdi
movl %eax, %esi
callq 0x1d7ca
movq 0x4fc7f(%rip), %rcx     # 0x61328
movq %rcx, 0x20(%rax)
movq (%r14), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf90b
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20d35(%rip), %rdi     # 0x3242e
leaq 0x20bd4(%rip), %rsi     # 0x322d4
leaq 0x20d34(%rip), %rcx     # 0x3243b
movl $0x60, %edx
callq 0x4180
movq 0x20(%rbx), %rdi
callq 0x23e44
leaq 0x20e22(%rip), %rdi     # 0x32543
movq %rax, %rsi
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x1281a
cmpq $0x8, %rax
je 0x1177d
movq %rbx, %rdi
callq 0x1281a
movl $0x4a, %esi
cmpq $0x8, %rax
jb 0x11760
movq %rbx, %rdi
callq 0x1281a
movl $0x49, %esi
cmpq $0x9, %rax
jb 0x11772
movq (%rbx), %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %rbx
movq 0x4fbaf(%rip), %rax     # 0x61328
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
je 0x1187a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x1172b
movq %rax, %r12
movq %r15, %rdi
callq 0x1172b
movq (%r14), %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1d832
movq %rax, %r13
movq (%r15), %rdi
movl $0x2, %esi
callq 0x22d38
movq %rax, 0x20(%r13)
movq (%r15), %rdi
callq 0x1e053
movq %rax, (%rsp)
movq (%r15), %rdi
callq 0x1e053
movq %rax, %rbp
movq 0x4fb45(%rip), %rdx     # 0x61340
movq (%r14), %rdi
movl $0x2d, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r12
movq (%r15), %rdi
movl $0x1, %esi
callq 0x22d38
movq %rax, 0x20(%r12)
movq (%r14), %rdi
movl $0x3e, %esi
movq %r13, %rdx
movq (%rsp), %r14
movq %r14, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x1d832
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfaab
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xfaab
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfaab
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfaab
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1281a
movq %rax, %r12
movq %rbx, %rdi
callq 0x125dd
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xfb13
cmpq %r13, %r12
jbe 0x118f6
movq (%r14), %rdi
movl $0x49, %esi
jmp 0x1190b
jae 0x11917
movq (%r14), %rdi
testl %ebp, %ebp
je 0x11906
movl $0x4b, %esi
jmp 0x1190b
movl $0x4a, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x204f0(%rip), %rdx     # 0x31e3a
movq %rsp, %rdi
movl $0x80, %esi
callq 0x1dff3
movq (%r15), %rdi
movq %rax, %rsi
callq 0x1d945
movq %rax, %r13
movq (%r15), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1e29f
movq %rax, %r12
movq (%r15), %rdi
movl $0x33, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %r15, 0x30(%r12)
movq %r14, 0x28(%r12)
movw $0x101, 0x71(%r12)      # imm = 0x101
movq 0x18(%r12), %rcx
movq %rcx, 0x38(%rax)
movq %r14, 0x20(%rax)
movl $0x1, 0x30(%rax)
testq %rbx, %rbx
je 0x119b8
movq %r12, (%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e5d4
movq %rax, %rdi
callq 0x55ef
movq %rsp, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1192a
movq %rax, %rbx
movw $0x101, 0x71(%rax)      # imm = 0x101
movq 0x40(%r14), %r14
movq (%r15), %r12
movq %r12, %rdi
callq 0x5630
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2dbc2
movq (%r15), %rdx
leaq 0x4f850(%rip), %rsi     # 0x61278
leaq 0x40(%rsi), %rdi
addq $0x48, %rsi
callq 0x2d3ff
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/simp.c
// Function: vatypeinfo
static Node *
vatypeinfo(Simp *s, Node *n)
{
	Node *ti, *tp, *td, *tn;
	Type *ft, *vt, **st;
	size_t nst, i;
	char buf[1024];

	st = NULL;
	nst = 0;
	ft = exprtype(n->expr.args[0]);
	/* The structure of ft->sub:
	 *   [return, normal, args, ...]
	 *
	 * The structure of n->expr.sub:
	 *    [fn, normal, args, , variadic, args]
	 *
	 * We want to start at variadic, so we want
	 * to count from ft->nsub - 1, up to n->expr.nsub.
	 */
	for (i = ft->nsub - 1; i < n->expr.nargs; i++) {
		lappend(&st, &nst, exprtype(n->expr.args[i]));
	}
	vt = mktytuple(n->loc, st, nst);
	tagreflect(vt);

	/* make the decl */
	tn = mkname(Zloc, tydescid(buf, sizeof buf, vt));
	td = mkdecl(Zloc, tn, mktype(n->loc, Tybyte));
	td->decl.isglobl = 1;
	td->decl.isconst = 1;
	td->decl.ishidden = 1;

	/* and the var */
	ti = mkexpr(Zloc, Ovar, tn, NULL);
	ti->expr.type = td->decl.type;
	ti->expr.did = td->decl.did;

	/* and the pointer */
	tp = mkexpr(Zloc, Oaddr, ti, NULL);
	tp->expr.type = mktyptr(n->loc, td->decl.type);

	htput(s->globls, td, asmname(td));
	return tp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
movq 0x50(%rsi), %rax
movq (%rax), %rdi
callq 0x1e5d4
movq 0x70(%rax), %r13
decq %r13
cmpq 0x40(%r14), %r13
jae 0x11b59
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x50(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e5d4
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2d3ff
incq %r13
cmpq 0x40(%r14), %r13
jb 0x11b35
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq (%r14), %rdi
callq 0x231f4
movq %rax, %r15
movq %rax, %rdi
callq 0x13c0c
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x5855
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rax, %rsi
callq 0x1d945
movq %rax, %r12
movq (%r14), %rdi
movl $0x9, %esi
callq 0x22d38
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r12, %rsi
movq %rax, %rdx
callq 0x1e29f
movq %rax, %r15
movw $0x101, 0x71(%rax)      # imm = 0x101
movb $0x1, 0x76(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x33, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%r15), %rcx
movq %rcx, 0x38(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x12, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1d832
movq %rax, %r12
movq 0x28(%r15), %rsi
movq (%r14), %rdi
callq 0x231bc
movq %rax, 0x20(%r12)
movq 0x40(%rbx), %rbx
movq %r15, %rdi
callq 0x5630
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2dbc2
movq %r12, %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x11d67
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0xb, %eax
je 0x11d35
cmpl $0x8, %eax
je 0x11d06
cmpl $0x1, %eax
jne 0x11d6d
cmpq $0x0, 0x20(%r14)
je 0x11d67
xorl %r15d, %r15d
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x14703
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x11c9c
incq %r15
cmpq 0x20(%r14), %r15
jb 0x11cd4
jmp 0x11d67
movq %r14, %rdi
callq 0x1d672
cmpl $0x35, %eax
jne 0x11d45
movq 0x50(%r14), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x11d45
cmpl $0x6, 0x18(%rax)
jne 0x11d45
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfaab
xorl %eax, %eax
jmp 0x11d52
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xf7c2
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xfb13
testq %rax, %rax
je 0x11d67
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xfaab
popq %rbx
popq %r14
popq %r15
retq
movq 0x3227c(%rip), %rax     # 0x43ff0
movq (%rax), %rsi
movq %r14, %rdi
callq 0x139c1
leaq 0x20928(%rip), %rdi     # 0x326ae
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x11e60
movq %rbx, %rdi
callq 0x1d672
cmpl $0x36, %eax
jne 0x11dc3
cmpq $0x2, 0x40(%rbx)
jne 0x11e5a
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rbx
jmp 0x11d98
leal -0x38(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11df4
cmpq $0x0, 0x40(%rbx)
je 0x11e5a
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x11d8d
incq %r15
cmpq 0x40(%rbx), %r15
jb 0x11dd9
jmp 0x11e5a
cmpl $0x29, %eax
jne 0x11e5a
movq 0x50(%rbx), %rax
movq (%rax), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x11d8d
movq %r15, %rdi
callq 0x1d672
cmpl $0x39, %eax
jne 0x11e5a
cmpq $0x0, 0x40(%r15)
je 0x11e37
movq 0x50(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x10ffd
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
jmp 0x11e5a
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1d7ca
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x4f4d9(%rip), %rax     # 0x61328
movq 0x50(%rbx), %rcx
movq (%rcx), %rcx
movq %rax, 0x20(%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x208a2(%rip), %rdi     # 0x32709
leaq 0x20466(%rip), %rsi     # 0x322d4
leaq 0x2089e(%rip), %rcx     # 0x32713
movl $0x60c, %edx            # imm = 0x60C
callq 0x4180
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpq $0x7, %rax
ja 0x11f38
movq %rdi, %r14
leaq 0x20899(%rip), %rcx     # 0x32734
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %ebx
jmp 0x11f2f
movl $0x4, %ebx
jmp 0x11f2f
cmpq $0x0, 0x20(%r14)
je 0x11f2d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x11e80
addq %rax, %rbx
incq %r15
cmpq 0x20(%r14), %r15
jb 0x11ec1
jmp 0x11f2f
movq 0x20(%r14), %rax
movq %rax, %rcx
shrq $0x38, %rcx
jne 0x11f41
movl $0x1, %ebx
movl $0x7, %ecx
movq %rax, %rdx
shrq %cl, %rdx
testq %rdx, %rdx
je 0x11f2f
incq %rbx
addq $0x7, %rcx
cmpq $0x8, %rbx
jne 0x11ef3
leaq 0x209e9(%rip), %rdi     # 0x328fb
xorl %eax, %eax
callq 0x13a00
movl $0x1, %ebx
jmp 0x11f2f
movl $0x2, %ebx
jmp 0x11f2f
movq 0x20(%r14), %rbx
jmp 0x11f2f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x209d1(%rip), %rdi     # 0x32910
jmp 0x11f12
leaq 0x209a0(%rip), %rdi     # 0x328e8
jmp 0x11f12
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdx), %r15
movq 0x20(%rdx), %rdi
callq 0x4120
movq %rax, %rbp
testq %r15, %r15
je 0x11fb2
movq %r15, %rdi
callq 0x4120
leaq (%rax,%rbp), %r12
incq %r12
addq %rax, %rbp
addq $0x2, %rbp
movq %rbp, %rdi
callq 0x2d379
movq %rax, %r15
movq 0x18(%r13), %rcx
movq 0x20(%r13), %r8
leaq 0x24504(%rip), %rdx     # 0x364a7
movq %rax, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2e42e
jmp 0x11fde
movq %rbp, %r12
incq %r12
movq %r12, %rdi
callq 0x2d379
movq %rax, %r15
movq 0x20(%r13), %rcx
leaq 0x24aef(%rip), %rdx     # 0x36abd
movq %rax, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2e42e
movq %rbp, %r12
movl $0x4, %edi
movq %r12, %rsi
callq 0x49bc
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d3ff
movq %r15, %rdi
movq %r12, %rsi
callq 0x49f5
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d3ff
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rsp, %r14
movq %rax, (%r14)
movl $0x1c, %esi
xorl %edi, %edi
callq 0x49bc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d3ff
movq 0x88(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f4a
movq 0x68(%r15), %rax
movq (%rax), %rdi
callq 0x12020
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2d3ff
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x4a1f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
cmpl $0x1c, (%rdi)
jne 0x12533
movq %rbx, %rdi
callq 0x23690
testl %eax, %eax
je 0x12533
xorl %r14d, %r14d
jmp 0x125c8
cmpl $0x1c, (%rbx)
jne 0x1259e
xorl %edi, %edi
xorl %esi, %esi
callq 0x4a1f
movq %rax, %r14
movl $0x4, %edi
xorl %esi, %esi
callq 0x49bc
movq %rax, %r15
movq %rbx, %rdi
callq 0x1248f
movq %rax, %r12
movq %rax, %rdi
callq 0x11e80
movq %rax, 0x20(%r15)
leaq 0x20(%r14), %r13
movq %r14, %rbp
addq $0x28, %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2d3ff
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2d3ff
cmpl $0x0, 0x10(%rbx)
je 0x125a9
movb $0x1, 0x18(%r14)
jmp 0x125a9
movq %rbx, %rdi
callq 0x12020
movq %rax, %r14
movq %rsp, %r15
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5855
movq %r15, %rdi
callq 0x4340
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0x22c44
movq %rax, %rbx
movl (%rax), %eax
addl $-0x14, %eax
cmpl $0x4, %eax
ja 0x12935
leaq 0x20005(%rip), %rcx     # 0x32854
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %r14d
jmp 0x1295d
cmpq $0x0, 0x78(%rbx)
je 0x12957
movl $0x4, %r14d
xorl %r15d, %r15d
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1289e
callq 0x1282d
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e681
movq %rax, %r14
incq %r15
cmpq 0x78(%rbx), %r15
jb 0x12877
jmp 0x1295d
cmpq $0x0, 0x70(%rbx)
je 0x1294f
movl $0x1, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1282d
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e681
movq %rax, %r14
incq %r15
cmpq 0x70(%rbx), %r15
jb 0x128c0
jmp 0x1295d
cmpq $0x0, 0x78(%rbx)
je 0x1294f
movl $0x1, %r14d
xorl %r15d, %r15d
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1e56c
movq %rax, %rdi
callq 0x1282d
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e681
movq %rax, %r14
incq %r15
cmpq 0x78(%rbx), %r15
jb 0x128f6
jmp 0x1295d
movq 0x68(%rbx), %rax
movq (%rax), %rdi
callq 0x1282d
jmp 0x1294a
movq %rbx, %rdi
callq 0x125dd
movl $0x1, %edi
movq %rax, %rsi
callq 0x2e681
movq %rax, %r14
jmp 0x1295d
movl $0x1, %r14d
jmp 0x1295d
movl $0x4, %r14d
movl $0x8, %esi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2e68c
// File: /workspace/github_c_makefile_star2_O1/oridb[P]mc/6/typeinfo.c
// Function: tyoffset
ssize_t
tyoffset(Type *ty, Node *memb)
{
	size_t i;
	size_t off;

	ty = tybase(ty);
	if (ty->type == Typtr)
		ty = tybase(ty->sub[0]);

	switch (memb->type) {
	case Nname:
		assert(ty->type == Tystruct);
		off = 0;
		for (i = 0; i < ty->nmemb; i++) {
			off = alignto(off, decltype(ty->sdecls[i]));
			if (!strcmp(namestr(memb), declname(ty->sdecls[i])))
				return off;
			off += size(ty->sdecls[i]);
		}
		die("bad offset");
		return 0;
	case Nlit:
		assert(ty->type == Tytuple);
		assert(memb->lit.intval < ty->nsub);
		off = 0;
		for (i = 0; i < memb->lit.intval; i++) {
			off += tysize(ty->sub[i]);
			off = alignto(off, ty->sub[i+1]);
		}
		return off;
	default:
		die("bad offset node type");
		return 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
callq 0x22c44
movq %rax, %r14
cmpl $0x12, (%rax)
jne 0x12997
movq 0x68(%r14), %rax
movq (%rax), %rdi
callq 0x22c44
movq %rax, %r14
movl 0x8(%rbx), %eax
cmpl $0x9, %eax
je 0x12a4a
cmpl $0xa, %eax
jne 0x12aae
cmpl $0x17, (%r14)
jne 0x12ab7
cmpq $0x0, 0x78(%r14)
je 0x12a3c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e56c
movq %r12, %rdi
movq %rax, %rsi
callq 0xee68
movq %rax, %r15
movq %rbx, %rdi
callq 0x1e73b
movq %rax, %r12
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rdi
callq 0x1e53d
movq %r12, %rdi
movq %rax, %rsi
callq 0x4230
testl %eax, %eax
je 0x12aa1
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rax
xorl %ecx, %ecx
cmpl $0x8, 0x8(%rax)
setne %cl
movq 0x20(%rax,%rcx,8), %rdi
callq 0x125dd
movq %rax, %r12
addq %r15, %r12
incq %r13
cmpq 0x78(%r14), %r13
jb 0x129c3
leaq 0x20017(%rip), %rdi     # 0x32a5a
xorl %eax, %eax
callq 0x13a00
cmpl $0x16, (%r14)
jne 0x12ad6
movq 0x30(%rbx), %rax
cmpq 0x70(%r14), %rax
jae 0x12af5
cmpq $0x0, 0x30(%rbx)
je 0x12a9e
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x68(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x125dd
addq %rax, %r15
movq 0x68(%r14), %rax
movq 0x8(%rax,%r12,8), %rsi
incq %r12
movq %r15, %rdi
callq 0xee68
movq %rax, %r15
cmpq 0x30(%rbx), %r12
jb 0x12a6f
jmp 0x12aa1
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1ffe0(%rip), %rdi     # 0x32a95
jmp 0x12a43
leaq 0x1ff66(%rip), %rdi     # 0x32a24
leaq 0x1fe87(%rip), %rsi     # 0x3294c
leaq 0x1ff6d(%rip), %rcx     # 0x32a39
movl $0x170, %edx            # imm = 0x170
callq 0x4180
leaq 0x1ff88(%rip), %rdi     # 0x32a65
leaq 0x1fe68(%rip), %rsi     # 0x3294c
leaq 0x1ff4e(%rip), %rcx     # 0x32a39
movl $0x17b, %edx            # imm = 0x17B
callq 0x4180
leaq 0x1ff7d(%rip), %rdi     # 0x32a79
leaq 0x1fe49(%rip), %rsi     # 0x3294c
leaq 0x1ff2f(%rip), %rcx     # 0x32a39
movl $0x17c, %edx            # imm = 0x17C
callq 0x4180
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
callq 0x22c44
movq %rax, %r14
movq 0x68(%rax), %rax
movq 0x70(%r14), %rbx
movq (%rax), %rdi
callq 0x12b78
xorl %ecx, %ecx
cmpl $0x8, %eax
setne %cl
subq %rcx, %rbx
movq 0x68(%r14), %rax
movq 0x70(%r14), %rcx
movq -0x8(%rax,%rcx,8), %rdi
callq 0x22c44
xorl %ecx, %ecx
cmpl $0x11, (%rax)
sete %cl
subq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
callq 0x125dd
movq %rax, %rbx
xorl %r14d, %r14d
movq %r14, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movq %r15, %rdi
callq 0x22c44
cmpl $0x1, (%rax)
je 0x12c3d
movq %r15, %rdi
callq 0x22c1c
testl %eax, %eax
je 0x12c37
movq %r15, %rdi
callq 0x12c7e
testl %eax, %eax
setne %al
cmpq $0x11, %rbx
setb %cl
andb %al, %cl
movl $0x8, %r14d
cmpb $0x1, %cl
jne 0x12c3d
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x12caf
movl (%r12), %ecx
movl 0x4(%r12), %eax
cmpl $0x3, %ecx
sete %dl
cmpl $0x3, %eax
sete %sil
orb %dl, %sil
jne 0x12c3d
cmpl $0x1, %ecx
je 0x12c4c
cmpl $0x2, %ecx
jne 0x12c70
movl $0x2, %r14d
cmpq $0x9, %rbx
jb 0x12c3d
movl $0x4, %r14d
cmpl $0x2, %eax
je 0x12c3d
cmpl $0x1, %eax
jne 0x12c70
movl $0x6, %r14d
jmp 0x12c3d
movl $0x1, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x3, %r14d
cmpq $0x9, %rbx
jb 0x12c3d
movl $0x5, %r14d
cmpl $0x2, %eax
je 0x12c3d
cmpl $0x1, %eax
jne 0x12c70
movl $0x7, %r14d
jmp 0x12c3d
leaq 0x1fe33(%rip), %rdi     # 0x32aaa
xorl %eax, %eax
callq 0x13a00
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4e064(%rip), %r12     # 0x61278
movq 0xa0(%r12), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2dedf
movq %rax, %r14
cmpq $0x0, (%r15)
je 0x1325d
xorl %r15d, %r15d
movq 0xa0(%r12), %rdi
movq (%r14,%r15,8), %rsi
callq 0x2dd9a
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x12fa5
incq %r15
cmpq 0x8(%rsp), %r15
jb 0x13235
movq %r14, %rdi
callq 0x4040
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4dff7(%rip), %r14     # 0x61278
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x1f8e9(%rip), %rsi     # 0x32b78
xorl %eax, %eax
callq 0x4240
movl $0x1, %edi
movq %rbx, %rsi
callq 0x131fc
cmpq $0x0, 0x18(%r14)
je 0x132cb
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x132f9
incq %r15
cmpq 0x18(%r14), %r15
jb 0x132ad
cmpq $0x0, 0x48(%r14)
je 0x132f3
xorl %r15d, %r15d
movq 0x40(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x132f9
incq %r15
cmpq 0x48(%r14), %r15
jb 0x132d5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x13a5f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x3056a(%rip), %rbx     # 0x43ff0
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x4300
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x41f0
callq 0x4060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30493(%rip), %rbp     # 0x43fd0
movq (%rbp), %r12
callq 0x1d56c
movq %rax, %r13
movq %r15, %rdi
callq 0x1d580
leaq 0x1f22c(%rip), %rsi     # 0x32d84
movq %r12, %rdi
movq %r13, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x4240
movq (%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
movq (%rbp), %rsi
movl $0xa, %edi
callq 0x41f0
movl $0x1, %edi
callq 0x4320