LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/init.c
// Function: focus
static void
focus(struct initparser *p)
{
	struct type *t;

	switch (p->sub->type->kind) {
	case TYPEARRAY:
		t = p->sub->type->base;
		p->sub->u.idx = 0;
		if (p->sub->type->incomplete)
			p->sub->type->size = t->size;
		break;
	case TYPESTRUCT:
	case TYPEUNION:
		p->sub->u.mem = p->sub->type->u.structunion.members;
		t = p->sub->u.mem->type;
		break;
	default:
		fatal("internal error: init cursor has unexpected type");
		return;  /* unreachable */
	}
	subobj(p, t, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x408(%rdi), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
leal -0xf(%rdx), %esi
cmpl $0x2, %esi
jae 0xa10a
movq 0x48(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x408(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %r14
movq (%rax), %r15
addq $0x20, %rax
movq %rax, 0x408(%rbx)
leaq 0x400(%rbx), %rcx
cmpq %rcx, %rax
jne 0xa0f9
leaq 0xa534(%rip), %rdi      # 0x1461f
xorl %eax, %eax
callq 0xe058
movq 0x408(%rbx), %rax
movq %r14, 0x8(%rax)
movq %r15, (%rax)
movb $0x0, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpl $0xd, %edx
jne 0xa136
movq 0x20(%rcx), %r14
movq $0x0, 0x10(%rax)
movq 0x408(%rbx), %rax
movq 0x8(%rax), %rcx
cmpb $0x1, 0x3c(%rcx)
jne 0xa0ca
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rcx)
jmp 0xa0ca
leaq 0xa526(%rip), %rdi      # 0x14663
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe058
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/init.c
// Function: findmember
static bool
findmember(struct initparser *p, char *name)
{
	struct member *m;

	for (m = p->sub->type->u.structunion.members; m; m = m->next) {
		if (m->name) {
			if (strcmp(m->name, name) == 0) {
				p->sub->u.mem = m;
				subobj(p, m->type, m->offset);
				return true;
			}
		} else {
			subobj(p, m->type, m->offset);
			if (findmember(p, name))
				return true;
			--p->sub;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x408(%rdi), %rbp
movq 0x8(%rbp), %rax
movq 0x48(%rax), %r13
testq %r13, %r13
je 0xa212
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x400(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq (%r13), %rdi
testq %rdi, %rdi
je 0xa19d
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
jne 0xa205
jmp 0xa216
movq 0x8(%r13), %r15
movq 0x18(%r13), %r14
movq (%rbp), %r12
addq $0x20, %rbp
movq %rbp, 0x408(%rbx)
cmpq 0x8(%rsp), %rbp
jne 0xa1d0
leaq 0xa45d(%rip), %rdi      # 0x1461f
xorl %eax, %eax
callq 0xe058
movq 0x408(%rbx), %rbp
addq %r14, %r12
movq %r15, 0x8(%rbp)
movq %r12, (%rbp)
movb $0x0, 0x18(%rbp)
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0xa149
testb %al, %al
jne 0xa261
movq 0x408(%rbx), %rbp
addq $-0x20, %rbp
movq %rbp, 0x408(%rbx)
movq 0x28(%r13), %r13
testq %r13, %r13
jne 0xa186
xorl %eax, %eax
jmp 0xa263
movq %r13, 0x10(%rbp)
movq 0x8(%r13), %r14
movq 0x18(%r13), %r15
movq 0x408(%rbx), %rax
movq (%rax), %r13
addq $0x20, %rax
movq %rax, 0x408(%rbx)
cmpq 0x8(%rsp), %rax
jne 0xa253
leaq 0xa3da(%rip), %rdi      # 0x1461f
xorl %eax, %eax
callq 0xe058
movq 0x408(%rbx), %rax
addq %r15, %r13
movq %r14, 0x8(%rax)
movq %r13, (%rax)
movb $0x0, 0x18(%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/map.c
// Function: mapinit
void
mapinit(struct map *h, size_t cap)
{
	size_t i;

	assert(!(cap & cap - 1));
	h->len = 0;
	h->cap = cap;
	h->keys = xreallocarray(NULL, cap, sizeof(h->keys[0]));
	h->vals = xreallocarray(NULL, cap, sizeof(h->vals[0]));
	for (i = 0; i < cap; ++i)
		h->keys[i].str = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq -0x1(%rsi), %r15
testq %r15, %rsi
jne 0xa619
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0x18, %edx
xorl %edi, %edi
callq 0xe10e
movq %rax, 0x10(%r14)
movl $0x8, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0xe10e
movq %rax, 0x18(%r14)
testq %rbx, %rbx
je 0xa613
movq 0x10(%r14), %rax
incq %rbx
andq $-0x2, %rbx
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x20, %rax
movdqa 0xa181(%rip), %xmm1     # 0x14720
movdqa 0xa189(%rip), %xmm2     # 0x14730
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xa189(%rip), %xmm4     # 0x14740
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %ecx
notl %ecx
testb $0x1, %cl
je 0xa5f0
movq $0x0, -0x18(%rax)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0xa605
movq $0x0, (%rax)
paddq %xmm4, %xmm1
addq $0x30, %rax
addq $-0x2, %rbx
jne 0xa5b7
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa130(%rip), %rdi      # 0x14750
leaq 0xa13a(%rip), %rsi      # 0x14761
leaq 0xa139(%rip), %rcx      # 0x14767
movl $0x21, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/map.c
// Function: mapfree
void
mapfree(struct map *h, void del(void *))
{
	size_t i;

	if (del) {
		for (i = 0; i < h->cap; ++i) {
			if (h->keys[i].str)
				del(h->vals[i]);
		}
	}
	free(h->keys);
	free(h->vals);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa683
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa683
movq %rsi, %r14
movl $0x1, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rcx
cmpq $0x0, (%rcx,%r15,8)
je 0xa677
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq *%r14
movq 0x8(%rbx), %rax
incq %r12
addq $0x3, %r15
cmpq %rax, %r12
jb 0xa65d
movq 0x10(%rbx), %rdi
callq 0x3250
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/map.c
// Function: mapput
void **
mapput(struct map *h, struct mapkey *k)
{
	struct mapkey *oldkeys;
	void **oldvals;
	size_t i, j, oldcap;

	if (h->cap / 2 < h->len) {
		oldkeys = h->keys;
		oldvals = h->vals;
		oldcap = h->cap;
		h->cap *= 2;
		h->keys = xreallocarray(NULL, h->cap, sizeof(h->keys[0]));
		h->vals = xreallocarray(NULL, h->cap, sizeof(h->vals[0]));
		for (i = 0; i < h->cap; ++i)
			h->keys[i].str = NULL;
		for (i = 0; i < oldcap; ++i) {
			if (oldkeys[i].str) {
				j = keyindex(h, &oldkeys[i]);
				h->keys[j] = oldkeys[i];
				h->vals[j] = oldvals[i];
			}
		}
		free(oldkeys);
		free(oldvals);
	}
	i = keyindex(h, k);
	if (!h->keys[i].str) {
		h->keys[i] = *k;
		h->vals[i] = NULL;
		++h->len;
	}

	return &h->vals[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rbp
movq %rbp, %rax
shrq %rax
cmpq (%rdi), %rax
jae 0xa809
movq 0x10(%rbx), %rax
movq %rax, (%rsp)
movq 0x18(%rbx), %r15
leaq (,%rbp,2), %rsi
movq %rsi, 0x8(%rbx)
movl $0x18, %edx
xorl %edi, %edi
callq 0xe10e
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rsi
movl $0x8, %edx
xorl %edi, %edi
callq 0xe10e
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0xa7a6
movq 0x10(%rbx), %rax
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x20, %rax
movdqa 0x9fee(%rip), %xmm1     # 0x14720
movdqa 0x9ff6(%rip), %xmm2     # 0x14730
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x9ff6(%rip), %xmm4     # 0x14740
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0xa783
movq $0x0, -0x18(%rax)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0xa798
movq $0x0, (%rax)
paddq %xmm4, %xmm1
addq $0x30, %rax
addq $-0x2, %rcx
jne 0xa74a
testq %rbp, %rbp
je 0xa7f8
xorl %r12d, %r12d
movq (%rsp), %r13
cmpq $0x0, 0x8(%r13)
je 0xa7ec
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa85f
movq 0x10(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movdqu (%r13), %xmm0
movdqu %xmm0, (%rcx,%rdx,8)
movq 0x10(%r13), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movq (%r15,%r12,8), %rcx
movq 0x18(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %r12
addq $0x18, %r13
cmpq %r12, %rbp
jne 0xa7b2
movq (%rsp), %rdi
callq 0x3250
movq %r15, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa85f
movq 0x10(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
cmpq $0x0, 0x8(%rcx,%rdx,8)
jne 0xa848
leaq (%rcx,%rdx,8), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rcx)
movdqu (%r14), %xmm0
movdqu %xmm0, (%rcx)
movq 0x18(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq (%rbx)
shlq $0x3, %rax
addq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/map.c
// Function: keyindex
static size_t
keyindex(struct map *h, struct mapkey *k)
{
	size_t i;

	i = k->hash & h->cap - 1;
	while (h->keys[i].str && !keyequal(&h->keys[i], k))
		i = i + 1 & h->cap - 1;
	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r15
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r13
decq %r12
movq %r15, %rbx
andq %r12, %rbx
leaq (%rbx,%rbx,2), %rax
movq 0x8(%r13,%rax,8), %rdi
testq %rdi, %rdi
je 0xa8d2
movq %rsi, %r14
leaq (,%rax,8), %rax
addq %r13, %rax
cmpq %r15, (%rax)
jne 0xa8b4
movq 0x10(%rax), %rdx
cmpq 0x10(%r14), %rdx
jne 0xa8b4
movq 0x8(%r14), %rsi
callq 0x31b0
testl %eax, %eax
je 0xa8d2
incq %rbx
andq %r12, %rbx
leaq (%rbx,%rbx,2), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
jne 0xa898
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/pp.c
// Function: next
void
next(void)
{
	struct token *t;

	do t = rawnext();
	while (expand(t) || t->kind == TNEWLINE && !(ppflags & PPNEWLINE));
	tok = *t;
	if (tok.kind == TIDENT)
		keyword(&tok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x117d6(%rip), %rbx     # 0x1c108
callq 0xb02d
movq %rax, %r14
testq %rax, %rax
jne 0xa94a
movq %rbx, %rdi
callq 0xb207
movq %rbx, %r14
movq %r14, %rdi
callq 0xaa08
testb %al, %al
jne 0xa932
cmpl $0x2, (%r14)
jne 0xa967
movl 0x11686(%rip), %eax     # 0x1bfe8
andl $0x1, %eax
je 0xa932
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
leaq 0x11791(%rip), %rcx     # 0x1c108
movups %xmm0, (%rcx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
cmpl $0x4, (%rcx)
jne 0xa9f9
leaq 0x11776(%rip), %rax     # 0x1c108
movq 0x20(%rax), %rbx
movl $0x46, %r15d
xorl %r13d, %r13d
leaq 0xfc8a(%rip), %r14      # 0x1a630
leaq (%r15,%r13), %r12
shrq %r12
movq %r12, %rbp
shlq $0x4, %rbp
movq (%rbp,%r14), %rsi
movq %rbx, %rdi
callq 0x3140
testl %eax, %eax
je 0xa9d9
js 0xa9cf
incq %r12
movq %r12, %r13
jmp 0xa9d2
movq %r12, %r15
cmpq %r15, %r13
jb 0xa9a6
jmp 0xa9f9
addq %rbp, %r14
movq %rbx, %rdi
callq 0x3250
movl 0x8(%r14), %eax
leaq 0x11719(%rip), %rcx     # 0x1c108
movl %eax, (%rcx)
movq $0x0, 0x20(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/pp.c
// Function: peek
bool
peek(int kind)
{
	static struct token pending;
	struct token old;

	old = tok;
	next();
	if (tok.kind == kind) {
		next();
		return true;
	}
	pending = tok;
	tok = old;
	ctxpush(&pending, 1, NULL, pending.space);
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x111d1(%rip), %r14     # 0x1c108
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0xa920
movl (%r14), %ebp
cmpl %ebx, %ebp
jne 0xaf65
callq 0xa920
jmp 0xafdb
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x1107b(%rip)    # 0x1bff0
movq 0x20(%r14), %rax
movq %rax, 0x11090(%rip)     # 0x1c010
movups %xmm1, 0x11079(%rip)    # 0x1c000
leaq 0x11062(%rip), %r15     # 0x1bff0
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%r14)
movb 0x11045(%rip), %r14b    # 0x1bff5
leaq 0x11061(%rip), %rdi     # 0x1c018
movl $0x18, %esi
callq 0xe190
movq %r15, (%rax)
movq $0x1, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb %r14b, 0x1101a(%rip)    # 0x1bff5
cmpl %ebx, %ebp
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/pp.c
// Function: ctxnext
static struct token *
ctxnext(void)
{
	struct frame *f;
	struct token *t;
	struct macro *m;
	bool space;
	size_t i;

again:
	for (f = arraylast(&ctx, sizeof(*f)); ctx.len; --f, ctx.len -= sizeof(*f)) {
		if (f->ntoken)
			break;
		if (f->macro)
			macrodone(f->macro);
	}
	if (ctx.len == 0)
		return NULL;
	m = f->macro;
	if (m && m->kind == MACROFUNC) {
		/* try to expand macro parameter */
		space = f->token->space;
		switch (f->token->kind) {
		case THASH:
			framenext(f);
			t = framenext(f);
			assert(t);
			i = macroparam(m, t);
			assert(i != -1);
			f = ctxpush(&m->arg[i].str, 1, NULL, space);
			break;
		case TIDENT:
			i = macroparam(m, f->token);
			if (i == -1)
				break;
			framenext(f);
			if (m->arg[i].ntoken == 0)
				goto again;
			f = ctxpush(m->arg[i].token, m->arg[i].ntoken, NULL, space);
			break;
		}
		/* XXX: token concatenation */
	}
	return framenext(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10fd9(%rip), %r14     # 0x1c018
movl $0x18, %esi
movq %r14, %rdi
callq 0xe23f
movq %rax, %rbx
movq 0x10fca(%rip), %rax     # 0x1c020
testq %rax, %rax
je 0xb153
movq 0x8(%rbx), %r13
testq %r13, %r13
jne 0xb0bc
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xb0a6
movb $0x0, 0x10(%r15)
cmpl $0x1, (%r15)
jne 0xb09f
cmpq $0x0, 0x20(%r15)
je 0xb09f
movq 0x28(%r15), %rax
movq (%rax), %rdi
callq 0x3250
movq 0x28(%r15), %rdi
callq 0x3250
movq 0x10f81(%rip), %rax     # 0x1c020
decq 0x10f8a(%rip)           # 0x1c030
addq $-0x18, %rbx
addq $-0x18, %rax
movq %rax, 0x10f6b(%rip)     # 0x1c020
jne 0xb05f
jmp 0xb153
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0xb1d2
cmpl $0x1, (%r12)
movq (%rbx), %r15
jne 0xb1d5
movb 0x5(%r15), %bpl
movl (%r15), %eax
cmpl $0x4, %eax
jne 0xb168
movq %r12, %rdi
movq %r15, %rsi
callq 0xba4d
cmpq $-0x1, %rax
je 0xb1d5
decq %r13
movq %r13, 0x8(%rbx)
addq $0x28, %r15
movq %r15, (%rbx)
movq 0x28(%r12), %rcx
imulq $0x38, %rax, %rax
movq 0x8(%rcx,%rax), %r13
testq %r13, %r13
je 0xb03f
addq %rax, %rcx
movq (%rcx), %r15
leaq 0x10eea(%rip), %rdi     # 0x1c018
movl $0x18, %esi
callq 0xe190
movq %rax, %rbx
movq %r15, (%rax)
movq %r13, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb %bpl, 0x5(%r15)
jmp 0xb1d5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x6f, %eax
jne 0xb1d5
leaq 0x28(%r15), %rsi
addq $-0x2, %r13
movq %r13, 0x8(%rbx)
addq $0x50, %r15
movq %r15, (%rbx)
movq %r12, %rdi
callq 0xba4d
cmpq $-0x1, %rax
je 0xb1e8
movq 0x28(%r12), %rcx
imulq $0x38, %rax, %rax
leaq (%rcx,%rax), %r15
addq $0x10, %r15
leaq 0x10e72(%rip), %rdi     # 0x1c018
movl $0x18, %esi
callq 0xe190
movq %rax, %rbx
movq %r15, (%rax)
movq $0x1, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb %bpl, 0x5(%r15)
movl $0x1, %r13d
jmp 0xb1d5
movq (%rbx), %r15
decq %r13
movq %r13, 0x8(%rbx)
leaq 0x28(%r15), %rax
movq %rax, (%rbx)
jmp 0xb156
leaq 0x95bc(%rip), %rdi      # 0x147ab
leaq 0x9594(%rip), %rsi      # 0x1478a
leaq 0x9592(%rip), %rcx      # 0x1478f
movl $0xb8, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/pp.c
// Function: macroparam
static size_t
macroparam(struct macro *m, struct token *t)
{
	size_t i;

	if (t->kind == TIDENT) {
		for (i = 0; i < m->nparam; ++i) {
			if (strcmp(m->param[i].name, t->lit) == 0)
				return i;
		}
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $-0x1, %rbx
cmpl $0x4, (%rsi)
jne 0xba97
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0xba97
movq 0x18(%rdi), %r12
movq 0x20(%rsi), %r14
xorl %r13d, %r13d
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
je 0xba94
incq %r13
addq $0x10, %r12
cmpq %r13, %r15
jne 0xba76
jmp 0xba97
movq %r13, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: scanfrom
void
scanfrom(const char *name, FILE *file)
{
	struct scanner *s;

	s = xmalloc(sizeof(*s));
	s->file = file;
	s->buf.str = NULL;
	s->buf.len = 0;
	s->buf.cap = 0;
	s->usebuf = false;
	s->loc.file = name;
	s->loc.line = 1;
	s->loc.col = 0;
	s->next = scanner;
	if (file)
		nextchar(s);
	scanner = s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x48, %edi
callq 0xe142
movq %rax, %rbx
movq %r14, 0x8(%rax)
movb $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
movq %r15, 0x10(%rbx)
movq $0x1, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq 0x10568(%rip), %rax     # 0x1c050
movq %rax, 0x40(%rbx)
testq %r14, %r14
je 0xbaf9
movq %rbx, %rdi
callq 0xbb06
movq %rbx, 0x10550(%rip)     # 0x1c050
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: nextchar
static void
nextchar(struct scanner *s)
{
	int c;

	if (s->usebuf)
		bufadd(&s->buf, s->chr);
	for (;;) {
		s->chr = getc(s->file);
		if (s->chr == '\n') {
			++s->loc.line, s->loc.col = 0;
			break;
		}
		++s->loc.col;
		if (s->chr != '\\')
			break;
		c = getc(s->file);
		if (c != '\n') {
			ungetc(c, s->file);
			break;
		}
		++s->loc.line, s->loc.col = 0;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x4(%rdi)
jne 0xbb40
leaq 0x28(%rbx), %rdi
movl (%rbx), %esi
callq 0xc23b
jmp 0xbb40
incq 0x20(%rbx)
cmpl $0x5c, %eax
jne 0xbb5c
movq 0x8(%rbx), %rdi
callq 0x3220
cmpl $0xa, %eax
jne 0xbb5e
incq 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rdi
callq 0x3220
movl %eax, (%rbx)
cmpl $0xa, %eax
jne 0xbb1d
incq 0x18(%rbx)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rsi
movl %eax, %edi
popq %rbx
jmp 0x31a0
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: scanopen
void
scanopen(void)
{
	if (!scanner->file) {
		scanner->file = fopen(scanner->loc.file, "r");
		if (!scanner->file)
			fatal("open %s:", scanner->loc.file);
		nextchar(scanner);
	}
}

// Assembly:
movq 0x104df(%rip), %rax     # 0x1c050
cmpq $0x0, 0x8(%rax)
je 0xbb79
retq
pushq %rax
movq 0x10(%rax), %rdi
leaq 0x906c(%rip), %rsi      # 0x14bf1
callq 0x31e0
movq 0x104bf(%rip), %rdi     # 0x1c050
movq %rax, 0x8(%rdi)
testq %rax, %rax
jne 0xbbb3
movq 0x10(%rdi), %rsi
leaq 0x8af8(%rip), %rdi      # 0x1469d
xorl %eax, %eax
callq 0xe058
movq 0x1049d(%rip), %rdi     # 0x1c050
popq %rax
jmp 0xbb06
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: bufadd
static void
bufadd(struct buffer *b, int c)
{
	if (b->len >= b->cap) {
		b->cap = b->cap ? b->cap * 2 : 1<<8;
		b->str = xreallocarray(b->str, b->cap, 1);
	}
	b->str[b->len++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
cmpq %rdx, %rcx
jb 0xc27c
leaq (%rdx,%rdx), %rcx
testq %rdx, %rdx
movl $0x100, %esi            # imm = 0x100
cmovneq %rcx, %rsi
movq %rsi, 0x10(%r14)
movl $0x1, %edx
movq %rax, %rdi
callq 0xe10e
movq %rax, (%r14)
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: stringlit
static int
stringlit(struct scanner *s)
{
	s->usebuf = true;
	nextchar(s);
	for (;;) {
		switch (s->chr) {
		case '\\':
			escape(s);
			break;
		case '"':
			nextchar(s);
			return TSTRINGLIT;
		case '\n':
			error(&s->loc, "newline in string literal");
		case EOF:
			error(&s->loc, "EOF in string literal");
		default:
			nextchar(s);
			break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xbb06
leaq 0x10(%rbx), %r14
leaq 0x8b5c(%rip), %r15      # 0x14e0a
leaq 0x8b3b(%rip), %r12      # 0x14df0
movl (%rbx), %eax
cmpl $0x21, %eax
jg 0xc2ea
cmpl $-0x1, %eax
je 0xc2d3
cmpl $0xa, %eax
jne 0xc2e0
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xd55c
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xd55c
movq %rbx, %rdi
callq 0xbb06
jmp 0xc2b5
cmpl $0x5c, %eax
jne 0xc2f9
movq %rbx, %rdi
callq 0xc4f5
jmp 0xc2b5
cmpl $0x22, %eax
jne 0xc2e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbb06
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: op3
static int
op3(struct scanner *s, int t1, int t2, int t3)
{
	int c;

	c = s->chr;
	nextchar(s);
	if (s->chr == '=') {
		nextchar(s);
		return t2;
	}
	if (s->chr != c)
		return t1;
	nextchar(s);
	return t3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl (%rdi), %r12d
callq 0xbb06
movl (%r14), %eax
cmpl $0x3d, %eax
je 0xc33b
movl %r15d, %ebx
cmpl %r12d, %eax
jne 0xc345
movq %r14, %rdi
callq 0xbb06
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: charconst
static enum tokenkind
charconst(struct scanner *s)
{
	s->usebuf = true;
	nextchar(s);
	for (;;) {
		switch (s->chr) {
		case '\\':
			escape(s);
			break;
		case '\'':
			nextchar(s);
			return TCHARCONST;
		case '\n':
			error(&s->loc, "newline in character constant");
		case EOF:
			error(&s->loc, "EOF in character constant");
		default:
			nextchar(s);
			break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xbb06
leaq 0x10(%rbx), %r14
leaq 0x8b17(%rip), %r15      # 0x14e86
leaq 0x8af2(%rip), %r12      # 0x14e68
movl (%rbx), %eax
cmpl $0x26, %eax
jg 0xc3ab
cmpl $-0x1, %eax
je 0xc394
cmpl $0xa, %eax
jne 0xc3a1
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xd55c
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xd55c
movq %rbx, %rdi
callq 0xbb06
jmp 0xc376
cmpl $0x5c, %eax
jne 0xc3ba
movq %rbx, %rdi
callq 0xc4f5
jmp 0xc376
cmpl $0x27, %eax
jne 0xc3a1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbb06
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: op4
static int
op4(struct scanner *s, int t1, int t2, int t3, int t4)
{
	int c;

	c = s->chr;
	nextchar(s);
	if (s->chr == '=') {
		nextchar(s);
		return t2;
	}
	if (s->chr != c)
		return t1;
	nextchar(s);
	if (s->chr != '=')
		return t3;
	nextchar(s);
	return t4;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movl (%rdi), %r13d
callq 0xbb06
movl (%rbx), %eax
cmpl $0x3d, %eax
jne 0xc407
movq %rbx, %rdi
callq 0xbb06
movl %r15d, %r12d
jmp 0xc41f
cmpl %r13d, %eax
jne 0xc41f
movq %rbx, %rdi
callq 0xbb06
cmpl $0x3d, (%rbx)
movl %r14d, %r15d
movl %ebp, %r12d
je 0xc3fa
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: number
static enum tokenkind
number(struct scanner *s)
{
	bool allowsign = false;

	s->usebuf = true;
	for (;;) {
		nextchar(s);
		switch (s->chr) {
		case 'e':
		case 'E':
		case 'p':
		case 'P':
			allowsign = true;
			break;
		case '+':
		case '-':
			if (!allowsign)
				goto done;
			break;
		case '_':
		case '.':
			allowsign = false;
			break;
		default:
			if (!isalnum(s->chr))
				goto done;
			allowsign = false;
		}
	}
done:
	return TNUMBER;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
xorl %eax, %eax
movabsq $0x400002004000000, %r14 # imm = 0x400002004000000
movl $0x5, %r15d
movabsq $0x10000000000008, %r12 # imm = 0x10000000000008
movl %eax, %ebp
movq %rbx, %rdi
callq 0xbb06
movl (%rbx), %ecx
movb $0x1, %al
leal -0x2b(%rcx), %edx
cmpl $0x3a, %edx
ja 0xc493
btq %rdx, %r14
jb 0xc45f
btq %rdx, %r15
jb 0xc48b
btq %rdx, %r12
jae 0xc493
xorl %eax, %eax
jmp 0xc45f
testb $0x1, %bpl
jne 0xc45f
jmp 0xc4ac
cmpl $0x70, %ecx
je 0xc45f
movslq %ecx, %r13
callq 0x3240
movq (%rax), %rcx
xorl %eax, %eax
testb $0x8, (%rcx,%r13,2)
jne 0xc45f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: ident
static int
ident(struct scanner *s)
{
	s->usebuf = true;
	while (isalnum(s->chr) || s->chr == '_')
		nextchar(s);

	return TIDENT;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0x3240
movq %rax, %r14
movslq (%rbx), %rax
cmpq $0x5f, %rax
je 0xc4e3
movq (%r14), %rcx
movzwl (%rcx,%rax,2), %eax
andl $0x8, %eax
je 0xc4ed
movq %rbx, %rdi
callq 0xbb06
jmp 0xc4ce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scan.c
// Function: escape
static void
escape(struct scanner *s)
{
	nextchar(s);
	if (s->chr == 'x') {
		nextchar(s);
		if (!isxdigit(s->chr))
			error(&s->loc, "invalid hexadecimal escape sequence");
		do nextchar(s);
		while (isxdigit(s->chr));
	} else if (isodigit(s->chr)) {
		nextchar(s);
		if (isodigit(s->chr)) {
			nextchar(s);
			if (isodigit(s->chr))
				nextchar(s);
		}
	} else if (strchr("'\"?\\abfnrtv", s->chr)) {
		nextchar(s);
	} else {
		error(&s->loc, "invalid escape sequence");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbb06
movl (%rbx), %esi
cmpl $0x78, %esi
jne 0xc554
movq %rbx, %rdi
callq 0xbb06
callq 0x3240
movq %rax, %r14
movq (%rax), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xc537
leaq 0x10(%rbx), %rdi
leaq 0x88f0(%rip), %rsi      # 0x14e20
xorl %eax, %eax
callq 0xd55c
movq %rbx, %rdi
callq 0xbb06
movq (%r14), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xc537
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %esi, %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc584
movq %rbx, %rdi
callq 0xbb06
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc54c
movq %rbx, %rdi
callq 0xbb06
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc54c
jmp 0xc59a
leaq 0x88b9(%rip), %rdi      # 0x14e44
movl $0xc, %edx
callq 0x3120
testq %rax, %rax
je 0xc5a9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbb06
addq $0x10, %rbx
leaq 0x889c(%rip), %rsi      # 0x14e50
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd55c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: scopeinit
void
scopeinit(void)
{
	static struct decl builtins[] = {
		{.name = "__builtin_alloca",      .kind = DECLBUILTIN, .u.builtin = BUILTINALLOCA},
		{.name = "__builtin_constant_p",  .kind = DECLBUILTIN, .u.builtin = BUILTINCONSTANTP},
		{.name = "__builtin_expect",      .kind = DECLBUILTIN, .u.builtin = BUILTINEXPECT},
		{.name = "__builtin_inff",        .kind = DECLBUILTIN, .u.builtin = BUILTININFF},
		{.name = "__builtin_nanf",        .kind = DECLBUILTIN, .u.builtin = BUILTINNANF},
		{.name = "__builtin_offsetof",    .kind = DECLBUILTIN, .u.builtin = BUILTINOFFSETOF},
		{.name = "__builtin_types_compatible_p", .kind = DECLBUILTIN, .u.builtin = BUILTINTYPESCOMPATIBLEP},
		{.name = "__builtin_unreachable", .kind = DECLBUILTIN, .u.builtin = BUILTINUNREACHABLE},
		{.name = "__builtin_va_arg",      .kind = DECLBUILTIN, .u.builtin = BUILTINVAARG},
		{.name = "__builtin_va_copy",     .kind = DECLBUILTIN, .u.builtin = BUILTINVACOPY},
		{.name = "__builtin_va_end",      .kind = DECLBUILTIN, .u.builtin = BUILTINVAEND},
		{.name = "__builtin_va_start",    .kind = DECLBUILTIN, .u.builtin = BUILTINVASTART},
	};
	static struct decl valist;
	struct decl *d;

	for (d = builtins; d < builtins + LEN(builtins); ++d)
		scopeputdecl(&filescope, d);
	valist.name = "__builtin_va_list";
	valist.kind = DECLTYPE;
	valist.type = targ->typevalist;
	scopeputdecl(&filescope, &valist);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq $-0x48, %r14
leaq 0xeb75(%rip), %r15      # 0x1b150
leaq 0xfabe(%rip), %rbx      # 0x1c0a0
leaq (%r14,%r15), %rsi
addq $0x48, %rsi
movq %rbx, %rdi
callq 0xc644
addq $0x48, %r14
cmpq $0x318, %r14            # imm = 0x318
jb 0xc5e2
leaq 0x898b(%rip), %rax      # 0x14f91
movq %rax, 0xfa4b(%rip)      # 0x1c058
leaq 0xfa44(%rip), %rsi      # 0x1c058
movl $0x0, 0xfa42(%rip)      # 0x1c060
leaq 0xfadb(%rip), %rax      # 0x1c100
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0xfa35(%rip)      # 0x1c068
leaq 0xfa66(%rip), %rdi      # 0x1c0a0
popq %rbx
popq %r14
popq %r15
jmp 0xc644
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: scopeputdecl
void
scopeputdecl(struct scope *s, struct decl *d)
{
	struct mapkey k;

	if (!s->decls.len)
		mapinit(&s->decls, 32);
	mapkey(&k, d->name, strlen(d->name));
	*mapput(&s->decls, &k) = d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x20(%rdi)
jne 0xc66a
movl $0x20, %esi
movq %r14, %rdi
callq 0xa52f
movq (%rbx), %r15
movq %r15, %rdi
callq 0x3090
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa500
movq %r14, %rdi
movq %r12, %rsi
callq 0xa6a0
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: mkscope
struct scope *
mkscope(struct scope *parent)
{
	struct scope *s;

	s = xmalloc(sizeof(*s));
	s->decls.len = 0;
	s->tags.len = 0;
	s->breaklabel = parent->breaklabel;
	s->continuelabel = parent->continuelabel;
	s->switchcases = parent->switchcases;
	s->parent = parent;

	return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x60, %edi
callq 0xe142
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, (%rax)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x40(%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rbx, 0x58(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: delscope
struct scope *
delscope(struct scope *s)
{
	struct scope *parent = s->parent;

	if (s->decls.len)
		mapfree(&s->decls, NULL);
	if (s->tags.len)
		mapfree(&s->tags, NULL);
	free(s);

	return parent;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58(%rdi), %rbx
cmpq $0x0, 0x20(%rdi)
je 0xc6ea
leaq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xa638
cmpq $0x0, (%r14)
je 0xc6fa
movq %r14, %rdi
xorl %esi, %esi
callq 0xa638
movq %r14, %rdi
callq 0x3250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: scopegetdecl
struct decl *
scopegetdecl(struct scope *s, const char *name, bool recurse)
{
	struct decl *d;
	struct mapkey k;

	mapkey(&k, name, strlen(name));
	do {
		d = s->decls.len ? mapget(&s->decls, &k) : NULL;
		s = s->parent;
	} while (!d && s && recurse);

	return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3090
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa500
cmpq $0x0, 0x20(%r14)
je 0xc74e
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xa8df
jmp 0xc750
xorl %eax, %eax
testq %rax, %rax
jne 0xc762
movq 0x58(%r14), %r14
testq %r14, %r14
je 0xc762
testb %bl, %bl
jne 0xc739
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: scopegettag
struct type *
scopegettag(struct scope *s, const char *name, bool recurse)
{
	struct type *t;
	struct mapkey k;

	mapkey(&k, name, strlen(name));
	do {
		t = s->tags.len ? mapget(&s->tags, &k) : NULL;
		s = s->parent;
	} while (!t && s && recurse);

	return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3090
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa500
cmpq $0x0, (%r14)
je 0xc7ad
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8df
jmp 0xc7af
xorl %eax, %eax
testq %rax, %rax
jne 0xc7c1
movq 0x58(%r14), %r14
testq %r14, %r14
je 0xc7c1
testb %bl, %bl
jne 0xc79a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/scope.c
// Function: scopeputtag
void
scopeputtag(struct scope *s, const char *name, struct type *t)
{
	struct mapkey k;

	if (!s->tags.len)
		mapinit(&s->tags, 32);
	mapkey(&k, name, strlen(name));
	*mapput(&s->tags, &k) = t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0xc7f4
movl $0x20, %esi
movq %r14, %rdi
callq 0xa52f
movq %r15, %rdi
callq 0x3090
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa500
movq %r14, %rdi
movq %r12, %rsi
callq 0xa6a0
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/stmt.c
// Function: label
static bool
label(struct func *f, struct scope *s)
{
	char *name;
	struct gotolabel *g;
	struct block *b;
	unsigned long long i;

	attr(NULL, 0);
	switch (tok.kind) {
	case TCASE:
		next();
		if (!s->switchcases)
			error(&tok.loc, "'case' label must be in switch");
		b = mkblock("switch_case");
		funclabel(f, b);
		i = intconstexpr(s, true);
		switchcase(s->switchcases, i, b);
		expect(TCOLON, "after case expression");
		break;
	case TDEFAULT:
		next();
		if (!s->switchcases)
			error(&tok.loc, "'default' label must be in switch");
		if (s->switchcases->defaultlabel)
			error(&tok.loc, "multiple 'default' labels");
		expect(TCOLON, "after 'default'");
		s->switchcases->defaultlabel = mkblock("switch_default");
		funclabel(f, s->switchcases->defaultlabel);
		break;
	case TIDENT:
		name = tok.lit;
		if (!peek(TCOLON))
			return false;
		g = funcgoto(f, name);
		g->defined = true;
		funclabel(f, g->label);
		break;
	default:
		return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
callq 0x33ec
leaq 0xef9b(%rip), %r15      # 0x1c108
movl (%r15), %eax
cmpl $0x4, %eax
je 0xd261
cmpl $0x12, %eax
je 0xd1f4
cmpl $0xd, %eax
jne 0xd290
callq 0xa920
cmpq $0x0, 0x50(%r14)
jne 0xd1a8
addq $0x8, %r15
leaq 0x80c2(%rip), %rsi      # 0x15260
movq %r15, %rdi
xorl %eax, %eax
callq 0xd55c
leaq 0x80d0(%rip), %rdi      # 0x1527f
callq 0xe2df
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xed54
movq %r14, %rdi
movl $0x1, %esi
callq 0x7359
movq 0x50(%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xe2a0
leaq 0x80a6(%rip), %rsi      # 0x1528b
movl $0x5f, %edi
callq 0xafeb
jmp 0xd28d
callq 0xa920
movq 0x50(%r14), %rax
testq %rax, %rax
jne 0xd218
leaq 0x8(%r15), %rdi
leaq 0x8094(%rip), %rsi      # 0x152a1
xorl %eax, %eax
callq 0xd55c
movq 0x50(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0xd234
addq $0x8, %r15
leaq 0x8099(%rip), %rsi      # 0x152c3
movq %r15, %rdi
xorl %eax, %eax
callq 0xd55c
leaq 0x6974(%rip), %rsi      # 0x13baf
movl $0x5f, %edi
callq 0xafeb
leaq 0x8091(%rip), %rdi      # 0x152dd
callq 0xe2df
movq 0x50(%r14), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xd288
movq 0x20(%r15), %r14
movl $0x5f, %edi
callq 0xaf24
testb %al, %al
je 0xd29f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf1ae
movb $0x1, 0x8(%rax)
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xed54
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0xd290
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/targ.c
// Function: targinit
void
targinit(const char *name)
{
	size_t i;
	enum typequal qual;

	if (!name) {
		/* TODO: provide a way to set this default */
		targ = &alltargs[0];
	}
	for (i = 0; i < LEN(alltargs) && !targ; ++i) {
		if (strcmp(alltargs[i].name, name) == 0)
			targ = &alltargs[i];
	}
	if (!targ)
		fatal("unknown target '%s'", name);
	typechar.u.basic.issigned = targ->signedchar;
	qual = QUALNONE;
	typeadjvalist = typeadjust(targ->typevalist, &qual);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xd305
movq 0xee47(%rip), %r14      # 0x1c100
testq %r14, %r14
jne 0xd313
movq %rdi, %rbx
leaq 0xd7c8(%rip), %r14      # 0x1aa90
xorl %r15d, %r15d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3140
testl %eax, %eax
je 0xd30c
cmpq $0x1, %r15
ja 0xd2eb
incq %r15
addq $0x20, %r14
testl %eax, %eax
jne 0xd2cb
leaq 0x7ffa(%rip), %rdi      # 0x152ec
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe058
movq 0xedfd(%rip), %r14      # 0x1c100
jmp 0xd313
leaq 0xd784(%rip), %r14      # 0x1aa90
movq %r14, 0xeded(%rip)      # 0x1c100
cmpl $0x0, 0x18(%r14)
leaq 0xe729(%rip), %rax      # 0x1ba48
setne 0x40(%rax)
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%r14), %rdi
callq 0xdc0d
leaq 0xedf2(%rip), %rcx      # 0x1c130
movq %rax, (%rcx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/token.c
// Function: tokenprint
void
tokenprint(const struct token *t)
{
	const char *str;

	if (t->space)
		fputc(' ', stdout);
	switch (t->kind) {
	case TIDENT:
	case TNUMBER:
	case TCHARCONST:
	case TSTRINGLIT:
		str = t->lit;
		break;
	case TNEWLINE:
		str = "\n";
		break;
	case TEOF:
		return;
	default:
		str = tokstr[t->kind];
	}
	if (!str)
		fatal("cannot print token %d", t->kind);
	fputs(str, stdout);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x5(%rdi)
jne 0xd36a
movq 0xdc63(%rip), %rax      # 0x1afc0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x3110
movl (%rbx), %esi
leal -0x4(%rsi), %eax
cmpl $0x4, %eax
jae 0xd392
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xd3a3
leaq 0x8014(%rip), %rdi      # 0x1539b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe058
jmp 0xd3a3
cmpl $0x1, %esi
je 0xd3b6
cmpl $0x2, %esi
jne 0xd3b8
leaq 0x7371(%rip), %rbx      # 0x14714
movq 0xdc16(%rip), %rax      # 0x1afc0
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x30f0
popq %rbx
retq
leaq 0xe251(%rip), %rax      # 0x1b610
leaq (%rax,%rsi,8), %rbx
jmp 0xd378
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/token.c
// Function: tokencheck
char *
tokencheck(const struct token *t, enum tokenkind kind, const char *msg)
{
	char want[64], got[64];

	if (t->kind != kind) {
		tokendesc(want, sizeof(want), kind, NULL);
		tokendesc(got, sizeof(got), t->kind, t->lit);
		error(&t->loc, "expected %s %s, saw %s", want, msg, got);
	}
	return t->lit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
cmpl %esi, (%rdi)
jne 0xd3ed
movq 0x20(%r14), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0xd42f
movl (%r14), %esi
movq 0x20(%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0xd42f
addq $0x8, %r14
leaq 0x7f95(%rip), %rsi      # 0x153b1
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0xd55c
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/token.c
// Function: tokendesc
static void
tokendesc(char *buf, size_t len, enum tokenkind kind, const char *lit)
{
	const char *class;
	bool quote = true;

	switch (kind) {
	case TEOF:       class = "EOF";                       break;
	case TIDENT:     class = "identifier"; quote = true;  break;
	case TNUMBER:    class = "number";     quote = true;  break;
	case TCHARCONST: class = "character";  quote = false; break;
	case TSTRINGLIT: class = "string";     quote = false; break;
	case TNEWLINE:   class = "newline";                   break;
	case TOTHER:     class = NULL;                        break;
	default:
		class = NULL;
		lit = kind < LEN(tokstr) ? tokstr[kind] : NULL;
	}
	if (class && lit)
		snprintf(buf, len, quote ? "%s '%s'" : "%s %s", class, lit);
	else if (class)
		snprintf(buf, len, "%s", class);
	else if (kind == TOTHER && !isprint(*(unsigned char *)lit))
		snprintf(buf, len, "<U+%04x>", *(unsigned char *)lit);
	else if (lit)
		snprintf(buf, len, "'%s'", lit);
	else
		snprintf(buf, len, "<unknown>");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal -0x1(%rsi), %eax
cmpl $0x6, %eax
ja 0xd4ad
movq %rdx, %r14
leaq 0x7fb1(%rip), %rdx      # 0x153f9
leaq 0x7ecd(%rip), %rcx      # 0x1531c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7f7d(%rip), %rcx      # 0x153dc
jmp 0xd50f
leaq 0x7f75(%rip), %rcx      # 0x153e0
jmp 0xd50f
testq %r14, %r14
setne %bpl
callq 0x3240
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0xd4cf
leaq 0x7f76(%rip), %rdx      # 0x15407
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
leaq 0x58ff(%rip), %rcx      # 0x12daa
jmp 0xd50f
cmpl $0x71, %esi
jae 0xd544
movl %esi, %eax
leaq 0xe151(%rip), %rcx      # 0x1b610
movq (%rcx,%rax,8), %r14
testq %r14, %r14
setne %bpl
cmpl $0x3, %esi
je 0xd477
testb %bpl, %bpl
je 0xd544
leaq 0x64f7(%rip), %rdx      # 0x139d2
movl $0x40, %esi
movq %rbx, %rdi
movq %r14, %rcx
jmp 0xd539
leaq 0x7f02(%rip), %rcx      # 0x153f1
jmp 0xd50f
leaq 0x7f09(%rip), %rdx      # 0x15401
leaq 0x7ee8(%rip), %rcx      # 0x153e7
jmp 0xd50f
leaq 0x7ef9(%rip), %rdx      # 0x15401
leaq 0x508c(%rip), %rcx      # 0x1259b
testq %r14, %r14
je 0xd52a
movl $0x40, %esi
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
leaq 0x64bd(%rip), %rdx      # 0x139ee
movl $0x40, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
movabsq $0x6e776f6e6b6e753c, %rax # imm = 0x6E776F6E6B6E753C
movq %rax, (%rbx)
movw $0x3e, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/token.c
// Function: error
void error(const struct location *loc, const char *fmt, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%zu:%zu: error: ", loc->file, loc->line, loc->col);
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	putc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0xd5bb
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 0xda36(%rip), %r15      # 0x1aff8
movq (%r15), %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
leaq 0x7df1(%rip), %rsi      # 0x153c8
movq %rax, %rdi
xorl %eax, %eax
callq 0x3160
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x3200
movq (%r15), %rsi
movl $0xa, %edi
callq 0x3150
movl $0x1, %edi
callq 0x3210
nop
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/tree.c
// Function: treeinsert
void *
treeinsert(void **root, unsigned long long key, size_t sz)
{
	void **a[MAXH];
	struct treenode *n = *root;
	int i = 0;

	a[i++] = root;
	while (n) {
		if (key == n->key) {
			n->new = false;
			return n;
		}
		a[i++] = &n->child[key > n->key];
		n = n->child[key > n->key];
	}
	assert(sz > sizeof(*n));
	n = xmalloc(sz);
	n->key = key;
	n->child[0] = n->child[1] = 0;
	n->height = 1;
	/* insert new node, rebalance ancestors.  */
	*a[--i] = n;
	while (i && balance(a[--i]))
		;
	n->new = true;
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x308, %rsp            # imm = 0x308
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdi, (%rsp)
xorl %r14d, %r14d
testq %rax, %rax
je 0xd667
cmpq %rbx, (%rax)
je 0xd7a4
setb %cl
movzbl %cl, %ecx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp,%r14,8)
movq (%rax), %rax
incq %r14
jmp 0xd63e
cmpq $0x20, %rdx
jbe 0xd7b7
movq %rdx, %rdi
callq 0xe142
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, 0x18(%rax)
movl %r14d, %edx
movq (%rsp,%rdx,8), %rcx
movq %rax, (%rcx)
movb $0x1, %cl
testl %r14d, %r14d
je 0xd7a6
decq %rdx
movq (%rsp,%rdx,8), %rsi
movq (%rsi), %rdi
movq 0x8(%rdi), %r10
xorl %r8d, %r8d
movl $0x0, %r9d
testq %r10, %r10
je 0xd6bf
movl 0x18(%r10), %r9d
movq 0x10(%rdi), %r10
testq %r10, %r10
je 0xd6cc
movl 0x18(%r10), %r8d
movl %r9d, %r10d
subl %r8d, %r10d
incl %r10d
cmpl $0x2, %r10d
ja 0xd6f5
cmpl %r8d, %r9d
cmovgl %r9d, %r8d
incl %r8d
movl %r8d, %r11d
subl 0x18(%rdi), %r11d
movl %r8d, 0x18(%rdi)
jmp 0xd793
xorl %r11d, %r11d
xorl %ebx, %ebx
cmpl %r8d, %r9d
setge %r11b
setl %bl
movq 0x8(%rdi,%rbx,8), %r10
movq 0x8(%r10,%r11,8), %r9
xorl %r14d, %r14d
movl $0x0, %r8d
testq %r9, %r9
je 0xd720
movl 0x18(%r9), %r8d
movq 0x8(%r10,%rbx,8), %r15
testq %r15, %r15
je 0xd72e
movl 0x18(%r15), %r14d
movl 0x18(%rdi), %ebp
cmpl %r14d, %r8d
jle 0xd76b
shll $0x3, %r11d
movq 0x8(%r9,%r11), %r14
shll $0x3, %ebx
movq %r14, 0x8(%rdi,%rbx)
movq 0x8(%r9,%rbx), %r14
movq %r14, 0x8(%r10,%r11)
movq %rdi, 0x8(%r9,%r11)
movq %r10, 0x8(%r9,%rbx)
movl %r8d, 0x18(%rdi)
movl %r8d, 0x18(%r10)
movl $0x1, %r11d
jmp 0xd786
movq %r9, 0x8(%rdi,%rbx,8)
movq %rdi, 0x8(%r10,%r11,8)
leal 0x1(%r8), %r9d
movl %r9d, 0x18(%rdi)
movl $0x2, %r11d
movq %r10, %r9
addl %r8d, %r11d
movl %r11d, 0x18(%r9)
movq %r9, (%rsi)
subl %ebp, %r11d
addq $-0x1, %rdx
jae 0xd7a6
testl %r11d, %r11d
jne 0xd6a2
jmp 0xd7a6
xorl %ecx, %ecx
movb %cl, 0x1c(%rax)
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7c5c(%rip), %rdi      # 0x1541a
leaq 0x7c65(%rip), %rsi      # 0x1542a
leaq 0x7c65(%rip), %rcx      # 0x15431
movl $0x55, %edx
callq 0x30e0
nop
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/type.c
// Function: mktype
struct type *
mktype(enum typekind kind, enum typeprop prop)
{
	struct type *t;

	t = xmalloc(sizeof(*t));
	t->kind = kind;
	t->prop = prop;
	t->value = NULL;
	t->incomplete = false;
	t->flexible = false;

	return t;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x58, %edi
callq 0xe142
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
movq $0x0, 0x18(%rax)
movw $0x0, 0x3c(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/type.c
// Function: mkpointertype
struct type *
mkpointertype(struct type *base, enum typequal qual)
{
	struct type *t;

	t = mktype(TYPEPOINTER, PROPSCALAR);
	t->base = base;
	t->qual = qual;
	t->size = 8;
	t->align = 8;
	if (base)
		t->prop |= base->prop & PROPVM;

	return t;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x58, %edi
callq 0xe142
movabsq $0x100000000c, %rcx     # imm = 0x100000000C
movq %rcx, (%rax)
movq $0x0, 0x18(%rax)
movw $0x0, 0x3c(%rax)
movq %rbx, 0x20(%rax)
movl %ebp, 0x38(%rax)
movq $0x8, 0x10(%rax)
movl $0x8, 0x8(%rax)
testq %rbx, %rbx
je 0xd857
movl 0x4(%rbx), %ecx
andl $0x40, %ecx
orl $0x10, %ecx
movl %ecx, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/type.c
// Function: mkarraytype
struct type *
mkarraytype(struct type *base, enum typequal qual, unsigned long long len)
{
	struct type *t;

	t = mktype(TYPEARRAY, 0);
	t->base = base;
	t->qual = qual;
	t->u.array.length = NULL;
	t->u.array.ptrqual = QUALNONE;
	t->incomplete = !len;
	if (t->base) {
		t->align = t->base->align;
		t->size = t->base->size * len;  /* XXX: overflow? */
	}

	return t;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x58, %edi
callq 0xe142
movq $0xd, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movb $0x0, 0x3d(%rax)
movq %r14, 0x20(%rax)
movl %ebp, 0x38(%rax)
movq %rcx, 0x40(%rax)
movl $0x0, 0x48(%rax)
testq %rbx, %rbx
sete 0x3c(%rax)
testq %r14, %r14
je 0xd8b3
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
imulq 0x10(%r14), %rbx
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq