LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display_bar
static void cli_display_bar(char *name, cli_progress_s *p, double percent)
{
	int name_width = CLI_TRUNCATED_DISPLAY_SHORT + strlen(CLI_TRUNCATED_ELLIPSE) + (cli_width > CLI_DEFAULT ? CLI_TRUNCATED_DISPLAY_SHORT : 0);
	fprintf(stderr, "\r%-*s : ", name_width, name);
	if (cli_width > CLI_SMALL)
		fprintf(stderr, "%'13" PRIu64 "/%-'13" PRIu64 " (", p->offset, p->size);
	fprintf(stderr, "%3.0f%%", isnan(percent) ? 0.0f : (percent > PERCENT ? PERCENT : percent));
	if (cli_width > CLI_SMALL)
		fprintf(stderr, ")");

	if (cli_width > CLI_DEFAULT)
	{
		int progress_bar_width = cli_width - CLI_LARGE;
		fprintf(stderr, " [");
		/*
		 * display overall progress bar
		 */
		for (int i = 0; i < progress_bar_width; i++)
			fprintf(stderr, "%c", i < progress_bar_width * percent  / PERCENT ? '=' : ' ');
		fprintf(stderr, "]");
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rcx
cmpl $0x51, 0x41ca(%rip)     # 0x81f8
pushq $0x18
popq %rax
pushq $0xe
popq %rdx
cmovgel %eax, %edx
movq 0x3fba(%rip), %r14      # 0x7ff8
movq (%r14), %rdi
leaq 0x133d(%rip), %rsi      # 0x5385
xorl %eax, %eax
callq 0x2210
cmpl $0x3f, 0x41a2(%rip)     # 0x81f8
jl 0x4070
movq (%r14), %rdi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
leaq 0x1325(%rip), %rsi      # 0x538e
xorl %eax, %eax
callq 0x2210
movq (%r14), %rdi
movsd 0x12a5(%rip), %xmm1     # 0x5320
movsd 0x8(%rsp), %xmm0
minsd %xmm0, %xmm1
cmpunordsd %xmm0, %xmm0
andnpd %xmm1, %xmm0
leaq 0x130a(%rip), %rsi      # 0x539f
movb $0x1, %al
callq 0x2210
cmpl $0x3f, 0x4155(%rip)     # 0x81f8
jl 0x40bb
movq (%r14), %rsi
pushq $0x29
popq %rdi
callq 0x21b0
movl 0x4142(%rip), %ebx      # 0x81f8
cmpl $0x51, %ebx
jge 0x40c6
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addl $-0x4b, %ebx
movq (%r14), %rcx
leaq 0x11b9(%rip), %rdi      # 0x528c
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2350
cvtsi2sd %ebx, %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x1230(%rip), %xmm0     # 0x5320
movsd %xmm0, 0x10(%rsp)
xorpd %xmm1, %xmm1
pushq $0x3d
popq %rbp
pushq $0x20
popq %r15
movq (%r14), %rsi
subl $0x1, %ebx
jb 0x4134
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movl %r15d, %edi
cmoval %ebp, %edi
movsd %xmm1, 0x8(%rsp)
callq 0x21b0
movsd 0x8(%rsp), %xmm1
addsd 0x11f6(%rip), %xmm1     # 0x5328
jmp 0x4101
pushq $0x5d
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_mod
extern void *mem_mod(const char *file, int line, const char *func, size_t size)
{
	void *m = malloc(size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
callq 0x2260
testq %rax, %rax
je 0x4172
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x129b(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_cod
extern void *mem_cod(const char *file, int line, const char *func, size_t count, size_t size)
{
	void *m = calloc(count, size);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, size);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
movq %r8, %rsi
callq 0x21e0
testq %rax, %rax
je 0x41b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1255(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_rod
extern void *mem_rod(const char *file, int line, const char *func, void *ptr, size_t newsize)
{
	void *m = realloc(ptr, newsize);
	if (!m)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, newsize);
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
movq %r8, %rsi
callq 0x2290
testq %rax, %rax
je 0x41fe
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x120f(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_sod
extern char *mem_sod(const char *file, int line, const char *func, const char *str)
{
	size_t len = strlen(str);
	char *new = strdup(str);
	if (!new)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, len);
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rdi
callq 0x2100
movq %rax, %r15
movq %r12, %rdi
callq 0x2370
testq %rax, %rax
je 0x424b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11c2(%rip), %rdi      # 0x5414
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_nod
extern char *mem_nod(const char *file, int line, const char *func, const char *str, size_t len)
{
	size_t olen = strlen(str);
	char *new = strndup(str, len);
	if (!new)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, olen < len ? len : olen);
	return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rdi
callq 0x2100
movq %rax, %r12
movq %r13, %rdi
movq %rbx, %rsi
callq 0x21c0
testq %rax, %rax
je 0x42a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r12
cmovaq %r12, %rbx
leaq 0x115f(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/albinoloverats[P]hide/common/src/mem.c
// Function: mem_aod
extern int mem_aod(const char *file, int line, const char *func, char **ptr, const char *template, ...)
{
	int r = 0;
	size_t l = strlen(template);
	va_list ap;
	va_start(ap, template);
#ifndef _WIN32
	r = vasprintf(ptr, template, ap);
#else
	if (!(*ptr))
		*ptr = mem_cod(file, line, func, l, VSN_SIZE);
	else
		*ptr = mem_rod(file, line, func, *ptr, l * VSN_SIZE);
	r = vsnprintf(*ptr, (l * VSN_SIZE) - 1, template, ap);
#endif
	va_end(ap);
	if (r < 0)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, l);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
movq %r9, 0x28(%rbx)
testb %al, %al
je 0x432f
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %r8, %rdi
callq 0x2100
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movq %rbx, 0x10(%rdx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%rdx)
movq %r13, %rdi
movq %r12, %rsi
callq 0x20f0
testl %eax, %eax
js 0x437d
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1090(%rip), %rdi      # 0x5414
movq %r14, %rsi
movl %ebp, %edx
movq 0x8(%rsp), %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3262
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/attr.c
// Function: attrspec
static bool
attrspec(struct attr *a, enum attrkind allowed)
{
	if (tok.kind != TLBRACK || !peek(TLBRACK))
		return false;
	while (parseattr(a, allowed, 0) || consume(TCOMMA))
		;
	expect(TRBRACK, "to end attribute specifier");
	expect(TRBRACK, "to end attribute specifier");
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x18d8a(%rip), %rax     # 0x1c108
cmpl $0x40, (%rax)
jne 0x33d4
movl %esi, %ebx
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0xa18a
testb %al, %al
je 0x33d4
pushq $0x6e
popq %rbp
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34b5
testb %al, %al
jne 0x3397
movl %ebp, %edi
callq 0xa28d
testb %al, %al
jne 0x3397
leaq 0xdc4b(%rip), %rbx      # 0x11004
pushq $0x41
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0xa26e
movl %ebp, %edi
movq %rbx, %rsi
callq 0xa26e
movb $0x1, %al
jmp 0x33d6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/attr.c
// Function: gnuattrspec
static bool
gnuattrspec(struct attr *a, enum attrkind allowed)
{
	if (!consume(T__ATTRIBUTE__))
		return false;
	while (parseattr(a, allowed, PREFIXGNU) || consume(TCOMMA))
		;
	expect(TLPAREN, "after '__attribute__' to begin attribute specifier");
	expect(TLPAREN, "after '__attribute__' to begin attribute specifier");
	while (parseattr(a, allowed, PREFIXGNU) || consume(TCOMMA))
		;
	expect(TRPAREN, "to end attribute specifier");
	expect(TRPAREN, "to end attribute specifier");
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x3f
popq %rdi
callq 0xa28d
movl %eax, %ebx
testb %al, %al
je 0x34aa
pushq $0x2
popq %r15
pushq $0x6e
popq %r12
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x34b5
testb %al, %al
jne 0x3429
movl %r12d, %edi
callq 0xa28d
testb %al, %al
jne 0x3429
leaq 0xdc66(%rip), %r15      # 0x110b3
pushq $0x42
popq %r12
movl %r12d, %edi
movq %r15, %rsi
callq 0xa26e
movl %r12d, %edi
movq %r15, %rsi
callq 0xa26e
pushq $0x2
popq %r15
pushq $0x6e
popq %r12
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x34b5
testb %al, %al
jne 0x346f
movl %r12d, %edi
callq 0xa28d
testb %al, %al
jne 0x346f
leaq 0xdb71(%rip), %r14      # 0x11004
pushq $0x43
popq %rbp
movl %ebp, %edi
movq %r14, %rsi
callq 0xa26e
movl %ebp, %edi
movq %r14, %rsi
callq 0xa26e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/attr.c
// Function: strip
static char *
strip(char *name)
{
	size_t len;

	len = strlen(name);
	if (len >= 4 && name[0] == '_' && name[1] == '_' && name[len - 2] == '_' && name[len - 1] == '_') {
		name[len - 2] = '\0';
		name += 2;
	}
	return name;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3090
cmpq $0x4, %rax
jb 0x371c
cmpb $0x5f, (%rbx)
jne 0x371c
cmpb $0x5f, 0x1(%rbx)
jne 0x371c
cmpb $0x5f, -0x2(%rbx,%rax)
jne 0x371c
cmpb $0x5f, -0x1(%rbx,%rax)
jne 0x371c
movb $0x0, -0x2(%rbx,%rax)
addq $0x2, %rbx
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: mkdecl
struct decl *
mkdecl(char *name, enum declkind k, struct type *t, enum typequal tq, enum linkage linkage)
{
	struct decl *d;

	d = xmalloc(sizeof(*d));
	memset(d, 0, sizeof(*d));
	d->name = name;
	d->kind = k;
	d->linkage = linkage;
	d->type = t;
	d->qual = tq;
	if (k == DECLOBJECT && t)
		d->u.obj.align = t->align;

	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r12
pushq $0x48
popq %rdi
callq 0xd0e3
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movq %r12, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
movl %r14d, 0x18(%rax)
cmpl $0x1, %r15d
setne %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x377b
movl 0x8(%rbx), %ecx
movl %ecx, 0x40(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: typename
struct type *
typename(struct scope *s, enum typequal *tq, struct expr **toeval)
{
	struct qualtype t;

	t = declspecs(s, NULL, NULL, NULL);
	if (t.type) {
		t = declarator(s, t, NULL, NULL, true);
		if (tq)
			*tq |= t.qual;
		if (toeval)
			*toeval = t.expr;
	}
	return t.type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x381f
cmpq $0x0, (%r12)
je 0x380e
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %r12
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x46fd
movq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
testq %r14, %r14
je 0x3801
movl 0x28(%rsp), %eax
orl %eax, (%r14)
testq %rbx, %rbx
je 0x380e
movq 0x30(%rsp), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: staticassert
static bool
staticassert(struct scope *s)
{
	struct stringlit msg;
	unsigned long long c;

	if (!consume(TSTATIC_ASSERT))
		return false;
	expect(TLPAREN, "after static_assert");
	c = intconstexpr(s, true);
	if (consume(TCOMMA)) {
		tokencheck(&tok, TSTRINGLIT, "after static assertion expression");
		stringconcat(&msg, true);
		if (!c)
			error(&tok.loc, "static assertion failed: %.*s", (int)(msg.size - 1), (char *)msg.data);
	} else if (!c) {
		error(&tok.loc, "static assertion failed");
	}
	expect(TRPAREN, "after static assertion");
	expect(TSEMICOLON, "after static assertion");
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0xa28d
movl %eax, %ebx
testb %al, %al
je 0x4fb1
leaq 0xcf9a(%rip), %rsi      # 0x11ea4
pushq $0x42
popq %rdi
callq 0xa26e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6f2d
movq %rax, %r15
pushq $0x6e
popq %rdi
callq 0xa28d
testb %al, %al
je 0x4f76
leaq 0x171d5(%rip), %r14     # 0x1c108
leaq 0xcf7e(%rip), %rdx      # 0x11eb8
pushq $0x7
popq %rsi
movq %r14, %rdi
callq 0xc3a7
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x6698
testq %r15, %r15
jne 0x4f94
movl (%rsp), %edx
decl %edx
movq 0x8(%rsp), %rcx
addq $0x8, %r14
leaq 0xcf70(%rip), %rsi      # 0x11eda
movq %r14, %rdi
xorl %eax, %eax
callq 0xc536
jmp 0x4f94
testq %r15, %r15
jne 0x4f94
leaq 0x17186(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xcf6b(%rip), %rsi      # 0x11ef8
xorl %eax, %eax
callq 0xc536
leaq 0xcf75(%rip), %r14      # 0x11f10
pushq $0x43
popq %rdi
movq %r14, %rsi
callq 0xa26e
pushq $0x61
popq %rdi
movq %r14, %rsi
callq 0xa26e
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: defineobj
static void
defineobj(struct decl *d, struct init *init, bool hasinit, struct func *f)
{
	if (d->type->incomplete)
		error(&tok.loc, "object '%s' has incomplete type", d->name);
	if (d->u.obj.align < d->type->align)
		d->u.obj.align = d->type->align;
	if (d->u.obj.storage == SDAUTO)
		funcinit(f, d, init, hasinit);
	else
		emitdata(d, init);
	d->defined = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x1, 0x3c(%rax)
jne 0x5313
movq (%rbx), %rdx
leaq 0x16e0b(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xccc7(%rip), %rsi      # 0x11fcf
xorl %eax, %eax
callq 0xc536
movq 0x10(%rbx), %rax
movl 0x8(%rax), %eax
cmpl %eax, 0x40(%rbx)
jge 0x531e
movl %eax, 0x40(%rbx)
cmpl $0x2, 0x44(%rbx)
jne 0x5338
movzbl %bpl, %ecx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xef08
jmp 0x5343
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf9aa
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: stringdecl
struct decl *
stringdecl(struct expr *expr)
{
	static struct map strings;
	struct mapkey key;
	void **entry;
	struct decl *d;

	if (!strings.len)
		mapinit(&strings, 64);
	assert(expr->kind == EXPRSTRING);
	mapkey(&key, expr->u.string.data, expr->u.string.size);
	entry = mapput(&strings, &key);
	d = *entry;
	if (!d) {
		d = mkdecl("string", DECLOBJECT, expr->type, QUALNONE, LINKNONE);
		d->value = mkglobal(d);
		emitdata(d, mkinit(0, expr->type->size, (struct bitfield){0}, expr));
		*entry = d;
	}
	return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x16c22(%rip)     # 0x1bf88
jne 0x5377
leaq 0x16c19(%rip), %rdi     # 0x1bf88
pushq $0x40
popq %rsi
callq 0x9988
cmpl $0x2, (%rbx)
jne 0x5405
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x995c
leaq 0x16bec(%rip), %rdi     # 0x1bf88
movq %r14, %rsi
callq 0x9a5b
movq (%rax), %r15
testq %r15, %r15
jne 0x53f8
movq %rax, %r14
movq 0x8(%rbx), %rdx
leaq 0xc1e1(%rip), %rdi      # 0x1159b
pushq $0x1
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3724
movq %rax, %r15
movq %rax, %rdi
callq 0xd2c0
movq %rax, 0x20(%r15)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
xorl %edi, %edi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x8f0c
movq %r15, %rdi
movq %rax, %rsi
callq 0xf9aa
movq %r15, (%r14)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf6cb(%rip), %rdi      # 0x14ad7
leaq 0xc118(%rip), %rsi      # 0x1152b
leaq 0xc15a(%rip), %rcx      # 0x11574
movl $0x46c, %edx            # imm = 0x46C
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: emittentativedefns
void
emittentativedefns(void)
{
	struct decl *d;

	for (d = tentativedefns; d; d = d->next) {
		if (!d->defined)
			defineobj(d, NULL, false, NULL);
	}
}

// Assembly:
pushq %rbx
leaq 0x16b7c(%rip), %rbx     # 0x1bfa8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x544e
cmpb $0x0, 0x30(%rbx)
jne 0x5448
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52d7
addq $0x38, %rbx
jmp 0x542c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: typequal
static int
typequal(enum typequal *tq)
{
	switch (tok.kind) {
	case TCONST:    *tq |= QUALCONST;    break;
	case TVOLATILE: *tq |= QUALVOLATILE; break;
	case TRESTRICT: *tq |= QUALRESTRICT; break;
	case T_ATOMIC: error(&tok.loc, "_Atomic type qualifier is not yet supported");
	default: return 0;
	}
	next();

	return 1;
}

// Assembly:
pushq %rbx
leaq 0x16cb0(%rip), %rax     # 0x1c108
movl (%rax), %ecx
cmpl $0xf, %ecx
je 0x5491
cmpl $0x22, %ecx
je 0x5474
cmpl $0x35, %ecx
je 0x5478
xorl %ebx, %ebx
cmpl $0x33, %ecx
jne 0x549e
pushq $0x8
jmp 0x5493
pushq $0x4
jmp 0x5493
addq $0x8, %rax
leaq 0xc2b0(%rip), %rsi      # 0x11733
xorl %ebx, %ebx
movq %rax, %rdi
xorl %eax, %eax
callq 0xc536
jmp 0x549e
pushq $0x2
popq %rax
orl %eax, (%rdi)
callq 0x9c1e
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/decl.c
// Function: getlinkage
static enum linkage
getlinkage(enum declkind kind, enum storageclass sc, struct decl *prior, bool filescope)
{
	if (sc & SCSTATIC)
		return filescope ? LINKINTERN : LINKNONE;
	if (sc & SCEXTERN || kind == DECLFUNC)
		return prior ? prior->linkage : LINKEXTERN;
	return filescope ? LINKEXTERN : LINKNONE;
}

// Assembly:
testb $0x8, %sil
jne 0x5cf1
testb $0x4, %sil
sete %al
cmpl $0x2, %edi
setne %sil
testb %al, %sil
jne 0x5cf5
testq %rdx, %rdx
je 0x5cfb
movl 0xc(%rdx), %eax
retq
movzbl %cl, %eax
retq
movzbl %cl, %eax
addl %eax, %eax
retq
pushq $0x2
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/eval.c
// Function: cast
static void
cast(struct expr *expr)
{
	unsigned size;
	unsigned long long m;

	size = expr->type->size;
	if (expr->type->prop & PROPFLOAT) {
		if (size == 4)
			expr->u.constant.f = (float)expr->u.constant.f;
	} else if (expr->type->prop & PROPINT) {
		expr->u.constant.u &= -1ull >> CHAR_BIT * sizeof(unsigned long long) - size * 8;
		if (expr->type->u.basic.issigned) {
			m = 1ull << size * 8 - 1;
			expr->u.constant.u = (expr->u.constant.u ^ m) - m;
		}
	}
}

// Assembly:
movq 0x8(%rdi), %rdx
movl 0x4(%rdx), %ecx
movl 0x10(%rdx), %eax
testb $0x20, %cl
jne 0x6112
testb $0x2, %cl
je 0x6111
shll $0x3, %eax
movq 0x30(%rdi), %rsi
movl %eax, %ecx
negb %cl
shlq %cl, %rsi
shrq %cl, %rsi
movq %rsi, 0x30(%rdi)
cmpb $0x1, 0x40(%rdx)
jne 0x6111
decb %al
pushq $0x1
popq %rdx
movl %eax, %ecx
shlq %cl, %rdx
btcq %rax, %rsi
subq %rdx, %rsi
movq %rsi, 0x30(%rdi)
retq
cmpl $0x4, %eax
jne 0x6111
cvtsd2ss 0x30(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: nullpointer
static bool
nullpointer(struct expr *e)
{
	if (e->kind != EXPRCONST)
		return false;
	if (e->type->kind == TYPENULLPTR)
		return true;
	if (!(e->type->prop & PROPINT) && (e->type->kind != TYPEPOINTER || e->type->base != &typevoid))
		return false;
	return e->u.constant.u == 0;
}

// Assembly:
cmpl $0x1, (%rdi)
jne 0x660c
movq 0x8(%rdi), %rcx
movl (%rcx), %edx
movb $0x1, %al
cmpl $0x11, %edx
je 0x660e
testb $0x2, 0x4(%rcx)
jne 0x660f
cmpl $0xc, %edx
jne 0x660c
movq 0x20(%rcx), %rax
cmpq 0x14996(%rip), %rax     # 0x1afa0
je 0x660f
xorl %eax, %eax
retq
cmpq $0x0, 0x30(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: binaryexpr
static struct expr *
binaryexpr(struct scope *s, struct expr *l, int i)
{
	struct expr *r;
	struct location loc;
	enum tokenkind op;
	int j, k;

	if (!l)
		l = castexpr(s);
	while ((j = precedence(tok.kind)) >= i) {
		op = tok.kind;
		loc = tok.loc;
		next();
		r = castexpr(s);
		while ((k = precedence(tok.kind)) > j)
			r = binaryexpr(s, r, k);
		l = mkbinaryexpr(&loc, op, l, r);
	}
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
jne 0x6db3
movq %r14, %rdi
callq 0x784c
movq %rax, %r15
leaq 0x1534e(%rip), %rbx     # 0x1c108
movl (%rbx), %ebp
movl %ebp, %edi
callq 0x79ee
cmpl 0xc(%rsp), %eax
jl 0x6e20
movl %eax, %r13d
movq 0x18(%rbx), %rax
movq %rax, 0x20(%rsp)
movups 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
callq 0x9c1e
movq %r14, %rdi
callq 0x784c
movq %rax, %r12
movl (%rbx), %edi
callq 0x79ee
cmpl %r13d, %eax
jle 0x6e09
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x6d8b
jmp 0x6deb
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x728c
movq %rax, %r15
jmp 0x6dba
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: expr
struct expr *
expr(struct scope *s)
{
	struct expr *r, *e, **end;

	end = &r;
	for (;;) {
		e = assignexpr(s);
		*end = e;
		end = &e->next;
		if (tok.kind != TCOMMA)
			break;
		next();
	}
	if (!r->next)
		return r;
	return mkexpr(EXPRCOMMA, e->type, r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r12
leaq 0x152c1(%rip), %r15     # 0x1c108
movq %rbx, %rdi
callq 0x6fa4
movq %rax, %r14
movq %rax, (%r12)
cmpl $0x6e, (%r15)
jne 0x6e6a
addq $0x20, %r14
callq 0x9c1e
movq %r14, %r12
jmp 0x6e47
movq (%rsp), %rdx
cmpq $0x0, 0x20(%rdx)
je 0x6e89
movq 0x8(%r14), %rsi
pushq $0xc
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6efa
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: commonreal
static struct type *
commonreal(struct expr **e1, struct expr **e2)
{
	struct type *t;

	t = typecommonreal((*e1)->type, bitfieldwidth(*e1), (*e2)->type, bitfieldwidth(*e2));
	*e1 = exprconvert(*e1, t);
	*e2 = exprconvert(*e2, t);

	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%rdi), %r15
callq 0x6678
movl %eax, %ebp
movq (%rbx), %rdi
movq 0x8(%rdi), %r12
callq 0x6678
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0xca57
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6618
movq %rax, (%r14)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6618
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: mkexpr
static struct expr *
mkexpr(enum exprkind k, struct type *t, struct expr *b)
{
	struct expr *e;

	e = xmalloc(sizeof(*e));
	e->qual = QUALNONE;
	e->type = t;
	e->lvalue = false;
	e->decayed = false;
	e->kind = k;
	e->base = b;
	e->next = NULL;
	e->toeval = NULL;

	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0x40
popq %rdi
callq 0xd0e3
andl $0x0, 0x10(%rax)
movq %r14, 0x8(%rax)
andw $0x0, 0x4(%rax)
movl %ebp, (%rax)
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: intconstexpr
unsigned long long
intconstexpr(struct scope *s, bool allowneg)
{
	struct expr *e;

	e = eval(condexpr(s));
	if (e->kind != EXPRCONST || !(e->type->prop & PROPINT))
		error(&tok.loc, "not an integer constant expression");
	if (!allowneg && e->type->u.basic.issigned && e->u.constant.u >> 63)
		error(&tok.loc, "integer constant expression cannot be negative");
	return e->u.constant.u;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x6b87
movq %rax, %rdi
callq 0x5d00
movq %rax, %rbx
cmpl $0x1, (%rax)
jne 0x6f51
movq 0x8(%rbx), %rax
testb $0x2, 0x4(%rax)
jne 0x6f6a
leaq 0x151b0(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xb746(%rip), %rsi      # 0x126a9
xorl %eax, %eax
callq 0xc536
testb %bpl, %bpl
jne 0x6f99
movq 0x8(%rbx), %rax
cmpb $0x1, 0x40(%rax)
jne 0x6f99
cmpq $0x0, 0x30(%rbx)
jns 0x6f99
leaq 0x15181(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xb73a(%rip), %rsi      # 0x126cc
xorl %eax, %eax
callq 0xc536
movq 0x30(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: mkassignexpr
static struct expr *
mkassignexpr(struct expr *l, struct expr *r)
{
	struct expr *e;

	e = mkexpr(EXPRASSIGN, l->type, NULL);
	e->u.assign.l = l;
	e->u.assign.r = exprconvert(r, l->type);
	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
pushq $0xb
popq %rdi
xorl %edx, %edx
callq 0x6efa
movq %rax, %r15
movq %r14, 0x30(%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6618
movq %rax, 0x38(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: mkunaryexpr
static struct expr *
mkunaryexpr(enum tokenkind op, struct expr *base)
{
	struct expr *expr;
	struct type *type;

	switch (op) {
	case TBAND:
		if (base->decayed) {
			expr = base;
			base = base->base;
			free(expr);
		}
		/*
		Allow struct and union types even if they are not lvalues,
		since we take their address when compiling member access.
		*/
		if (!base->lvalue && base->type->kind != TYPEFUNC && base->type->kind != TYPESTRUCT && base->type->kind != TYPEUNION)
			error(&tok.loc, "'&' operand is not an lvalue or function designator");
		if (base->kind == EXPRBITFIELD)
			error(&tok.loc, "cannot take address of bit-field");
		expr = mkexpr(EXPRUNARY, mkpointertype(base->type, base->qual), base);
		expr->op = op;
		return expr;
	case TMUL:
		if (base->type->kind != TYPEPOINTER)
			error(&tok.loc, "cannot dereference non-pointer");
		if (base->kind == EXPRUNARY && base->op == TBAND) {
			type = base->type->base;
			expr = base->base;
			expr->type = type;
		} else {
			expr = mkexpr(EXPRUNARY, base->type->base, base);
			expr->qual = base->type->qual;
			expr->lvalue = true;
			expr->op = op;
		}
		return decay(expr);
	}
	/* other unary operators get compiled as equivalent binary ones */
	fatal("internal error: unknown unary operator %d", op);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x4b, %edi
je 0x71fb
movl %edi, %esi
cmpl $0x4a, %edi
jne 0x723a
cmpb $0x1, 0x5(%rbx)
jne 0x718a
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3250
movq %r14, %rbx
cmpb $0x0, 0x4(%rbx)
jne 0x71b7
movq 0x8(%rbx), %rax
movl (%rax), %eax
addl $-0xe, %eax
cmpl $0x3, %eax
jb 0x71b7
leaq 0x14f63(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xbf2c(%rip), %rsi      # 0x130dc
xorl %eax, %eax
callq 0xc536
cmpl $0x4, (%rbx)
jne 0x71d5
leaq 0x14f45(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xbf42(%rip), %rsi      # 0x13110
xorl %eax, %eax
callq 0xc536
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0xc7d5
pushq $0x7
popq %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x6efa
movq %rax, %rbx
movl $0x4a, 0x14(%rax)
jmp 0x724a
movq 0x8(%rbx), %rax
cmpl $0xc, (%rax)
je 0x721d
leaq 0x14efd(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xbf1b(%rip), %rsi      # 0x13131
xorl %eax, %eax
callq 0xc536
cmpl $0x7, (%rbx)
jne 0x7255
cmpl $0x4a, 0x14(%rbx)
movq 0x8(%rbx), %rax
jne 0x7259
movq 0x20(%rax), %rax
movq 0x18(%rbx), %rdi
movq %rax, 0x8(%rdi)
jmp 0x7280
leaq 0xbf0f(%rip), %rdi      # 0x13150
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xcffb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rsi
pushq $0x7
popq %rdi
movq %rbx, %rdx
callq 0x6efa
movq %rax, %rdi
movq 0x8(%rbx), %rax
movl 0x38(%rax), %eax
movl %eax, 0x10(%rdi)
movb $0x1, 0x4(%rdi)
movl $0x4b, 0x14(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a72
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: decay
static struct expr *
decay(struct expr *e)
{
	struct type *t;
	enum typequal tq;

	/* XXX: combine with decl.c:adjust in some way? */
	t = e->type;
	tq = e->qual;
	switch (t->kind) {
	case TYPEARRAY:
		/*
		XXX: qualifiers should be applied to the element
		type of array types, not the array type itself

		assert(tq == QUALNONE);
		*/
		e = mkunaryexpr(TBAND, e);
		e->type = mkpointertype(t->base, t->qual | tq);
		e->decayed = true;
		break;
	case TYPEFUNC:
		e = mkunaryexpr(TBAND, e);
		e->decayed = true;
		break;
	}

	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movl (%r14), %eax
cmpl $0xe, %eax
je 0x8ab0
cmpl $0xd, %eax
jne 0x8ac2
movl 0x10(%rbx), %ebp
pushq $0x4a
popq %rdi
movq %rbx, %rsi
callq 0x715a
movq %rax, %rbx
movq 0x20(%r14), %rdi
orl 0x38(%r14), %ebp
movl %ebp, %esi
callq 0xc7d5
movq %rax, 0x8(%rbx)
jmp 0x8abe
pushq $0x4a
popq %rdi
movq %rbx, %rsi
callq 0x715a
movq %rax, %rbx
movb $0x1, 0x5(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/expr.c
// Function: mkincdecexpr
static struct expr *
mkincdecexpr(enum tokenkind op, struct expr *base, bool post)
{
	struct expr *e;

	if (!base->lvalue)
		error(&tok.loc, "operand of '%s' operator must be an lvalue", tokstr[op]);
	if (base->qual & QUALCONST)
		error(&tok.loc, "operand of '%s' operator is const qualified", tokstr[op]);
	e = mkexpr(EXPRINCDEC, base->type, base);
	e->op = op;
	e->u.incdec.post = post;
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
cmpb $0x0, 0x4(%rsi)
movl %edi, %r15d
jne 0x8ec1
leaq 0x1276c(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x13259(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa072(%rip), %rsi      # 0x12f2c
xorl %eax, %eax
callq 0xc536
testb $0x2, 0x10(%r14)
je 0x8eec
leaq 0x12741(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x1322e(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa072(%rip), %rsi      # 0x12f57
xorl %eax, %eax
callq 0xc536
movq 0x8(%r14), %rsi
pushq $0x5
popq %rdi
movq %r14, %rdx
callq 0x6efa
movl %ebp, 0x14(%rax)
movb %bl, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/init.c
// Function: mkinit
struct init *
mkinit(unsigned long long start, unsigned long long end, struct bitfield bits, struct expr *expr)
{
	struct init *init;

	init = xmalloc(sizeof(*init));
	init->start = start;
	init->end = end;
	init->expr = expr;
	init->bits = bits;
	init->next = NULL;

	return init;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0xd0e3
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl %ebp, 0x18(%rax)
andq $0x0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x408(%rdi), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
leal -0xf(%rdx), %esi
cmpl $0x2, %esi
jae 0x95c5
movq 0x48(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x408(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
jmp 0x95fc
cmpl $0xd, %edx
jne 0x95ee
movq 0x20(%rcx), %rsi
andq $0x0, 0x10(%rax)
movq 0x408(%rdi), %rax
movq 0x8(%rax), %rax
cmpb $0x1, 0x3c(%rax)
jne 0x95c1
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x95c1
leaq 0xa06e(%rip), %rdi      # 0x13663
xorl %eax, %eax
jmp 0xcffb
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/init.c
// Function: subobj
static void
subobj(struct initparser *p, struct type *t, unsigned long long off)
{
	off += p->sub->offset;
	if (++p->sub == p->obj + LEN(p->obj))
		fatal("internal error: too many designators");
	p->sub->type = t;
	p->sub->offset = off;
	p->sub->iscur = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq 0x408(%rdi), %rax
movq (%rax), %r12
addq $0x20, %rax
movq %rax, 0x408(%rdi)
leaq 0x400(%rdi), %rcx
cmpq %rcx, %rax
jne 0x9643
movq %rdi, %r15
leaq 0x9fea(%rip), %rdi      # 0x1361f
xorl %eax, %eax
callq 0xcffb
movq 0x408(%r15), %rax
addq %r14, %r12
movq %rbx, 0x8(%rax)
movq %r12, (%rax)
movb $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x408(%rdi), %r12
movq 0x8(%r12), %r15
addq $0x48, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x96e5
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9699
movq %r14, %rsi
callq 0x3140
testl %eax, %eax
jne 0x96ca
jmp 0x96d0
movq 0x8(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0x95fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x965d
testb %al, %al
jne 0x96e5
movq 0x408(%rbx), %r12
addq $-0x20, %r12
movq %r12, 0x408(%rbx)
addq $0x28, %r15
jmp 0x967b
movq %r15, 0x10(%r12)
movq 0x8(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0x95fc
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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), %rax
testq %rax, %rsi
jne 0x99e2
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
pushq $0x18
popq %rdx
xorl %edi, %edi
callq 0xd0af
movq %rax, 0x10(%r14)
pushq $0x8
popq %r15
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xd0af
movq %rax, 0x18(%r14)
subq $0x1, %rbx
jb 0x99dc
movq 0x10(%r14), %rax
andq $0x0, (%rax,%r15)
addq $0x18, %r15
jmp 0x99c7
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9d2d(%rip), %rdi      # 0x13716
leaq 0x9d37(%rip), %rsi      # 0x13727
leaq 0x9d36(%rip), %rcx      # 0x1372d
pushq $0x21
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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 0x9a3e
movq %rsi, %r14
pushq $0x1
popq %r15
xorl %r12d, %r12d
cmpq 0x8(%rbx), %r12
jae 0x9a3e
movq 0x10(%rbx), %rax
cmpq $0x0, (%rax,%r15,8)
je 0x9a35
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq *%r14
incq %r12
addq $0x3, %r15
jmp 0x9a19
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_O2/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 0x9b32
movq 0x10(%rbx), %rax
movq %rax, (%rsp)
movq 0x18(%rbx), %r15
leaq (,%rbp,2), %rsi
movq %rsi, 0x8(%rbx)
pushq $0x18
popq %rdx
xorl %edi, %edi
callq 0xd0af
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rsi
pushq $0x8
popq %r13
xorl %edi, %edi
movq %r13, %rdx
callq 0xd0af
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
subq $0x1, %rax
jb 0x9ad4
movq 0x10(%rbx), %rcx
andq $0x0, (%rcx,%r13)
addq $0x18, %r13
jmp 0x9abf
xorl %r12d, %r12d
movq (%rsp), %r13
cmpq %r12, %rbp
je 0x9b21
cmpq $0x0, 0x8(%r13)
je 0x9b18
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9b82
movq 0x10(%rbx), %rcx
imulq $0x18, %rax, %rdx
movups (%r13), %xmm0
movups %xmm0, (%rcx,%rdx)
movq 0x10(%r13), %rsi
movq %rsi, 0x10(%rcx,%rdx)
movq (%r15,%r12,8), %rcx
movq 0x18(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %r12
addq $0x18, %r13
jmp 0x9adb
movq (%rsp), %rdi
callq 0x3250
movq %r15, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b82
movq 0x10(%rbx), %rcx
imulq $0x18, %rax, %rdx
cmpq $0x0, 0x8(%rcx,%rdx)
jne 0x9b6b
addq %rdx, %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rcx)
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rbx), %rcx
andq $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_O2/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, %rbx
movq (%rsi), %r15
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r13
decq %r12
movq %r15, %r14
andq %r12, %r14
imulq $0x18, %r14, %rax
movq 0x8(%r13,%rax), %rdi
testq %rdi, %rdi
je 0x9bd4
addq %r13, %rax
cmpq %r15, (%rax)
jne 0x9bcf
movq 0x10(%rax), %rdx
cmpq 0x10(%rbx), %rdx
jne 0x9bcf
movq 0x8(%rbx), %rsi
callq 0x31b0
testl %eax, %eax
je 0x9bd4
incq %r14
jmp 0x9b9f
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x9ce7
movq %rax, %rbx
movq %rax, %rdi
callq 0x9d09
testb %al, %al
jne 0x9c29
cmpl $0x2, (%rbx)
jne 0x9c4d
movl 0x123a0(%rip), %eax     # 0x1bfe8
andl $0x1, %eax
je 0x9c29
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
leaq 0x124ad(%rip), %rcx     # 0x1c108
movups %xmm0, (%rcx)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
cmpl $0x4, (%rcx)
jne 0x9cd8
leaq 0x12492(%rip), %rax     # 0x1c108
movq 0x20(%rax), %rbx
pushq $0x46
popq %r14
xorl %r13d, %r13d
leaq 0x109a8(%rip), %r15     # 0x1a630
cmpq %r14, %r13
jae 0x9cd8
leaq (%r14,%r13), %r12
shrq %r12
movq %r12, %rbp
shlq $0x4, %rbp
movq (%rbp,%r15), %rsi
movq %rbx, %rdi
callq 0x3140
testl %eax, %eax
je 0x9cbb
js 0x9cb6
incq %r12
movq %r12, %r13
jmp 0x9c88
movq %r12, %r14
jmp 0x9c88
addq %rbp, %r15
movq %rbx, %rdi
callq 0x3250
movl 0x8(%r15), %eax
leaq 0x12437(%rip), %rcx     # 0x1c108
movl %eax, (%rcx)
andq $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_O2/michaelforney[P]cproc/pp.c
// Function: rawnext
static struct token *
rawnext(void)
{
	struct token *t;

	t = ctxnext();
	if (!t) {
		t = &tok;
		nextinto(t);
	}
	return t;
}

// Assembly:
pushq %rbx
callq 0xa2b0
movq %rax, %rbx
testq %rax, %rax
jne 0x9d04
leaq 0x1240c(%rip), %rbx     # 0x1c108
movq %rbx, %rdi
callq 0xa44a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
leaq 0x11f6d(%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 0x9c1e
movl (%r14), %ebp
cmpl %ebx, %ebp
jne 0xa1c9
callq 0x9c1e
jmp 0xa21e
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x11e17(%rip)    # 0x1bff0
movq 0x20(%r14), %rax
movq %rax, 0x11e2c(%rip)     # 0x1c010
movups %xmm1, 0x11e15(%rip)    # 0x1c000
leaq 0x11dfe(%rip), %rdi     # 0x1bff0
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%r14)
movzbl 0x11de1(%rip), %ecx     # 0x1bff5
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xa22c
cmpl %ebx, %ebp
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/pp.c
// Function: ctxpush
static struct frame *
ctxpush(struct token *t, size_t n, struct macro *m, bool space)
{
	struct frame *f;

	f = arrayadd(&ctx, sizeof(*f));
	f->token = t;
	f->ntoken = n;
	f->macro = m;
	if (n > 0)
		t[0].space = space;
	return f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x11dd2(%rip), %rdi     # 0x1c018
pushq $0x18
popq %rsi
callq 0xd12f
movq %r14, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
testq %r12, %r12
je 0xa262
movb %bl, 0x5(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11d56(%rip), %rbp     # 0x1c018
pushq $0x18
popq %r13
xorl %r14d, %r14d
movq %rbp, %rdi
movq %r13, %rsi
callq 0xd1dc
movq %rax, %rbx
movq 0x11d42(%rip), %rax     # 0x1c020
testq %rax, %rax
je 0xa419
movq 0x8(%rbx), %r12
testq %r12, %r12
jne 0xa33f
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xa32e
movb $0x0, 0x10(%r15)
cmpl $0x1, (%r15)
jne 0xa327
cmpq $0x0, 0x20(%r15)
je 0xa327
movq 0x28(%r15), %rax
movq (%rax), %rdi
callq 0x3250
movq 0x28(%r15), %rdi
callq 0x3250
movq 0x11cf9(%rip), %rax     # 0x1c020
decq 0x11d02(%rip)           # 0x1c030
addq $-0x18, %rbx
addq $-0x18, %rax
movq %rax, 0x11ce3(%rip)     # 0x1c020
jmp 0xa2de
movq %r13, %r15
movq 0x10(%rbx), %r13
testq %r13, %r13
je 0xa40b
cmpl $0x1, (%r13)
jne 0xa40b
movq %rbp, %r14
movq (%rbx), %rbp
movb 0x5(%rbp), %cl
movl (%rbp), %eax
cmpl $0x4, %eax
jne 0xa3c1
movb %cl, 0x7(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xabe1
cmpq $-0x1, %rax
je 0xa40b
decq %r12
movq %r12, 0x8(%rbx)
addq $0x28, %rbp
movq %rbp, (%rbx)
movq 0x28(%r13), %rcx
imulq $0x38, %rax, %rax
movq 0x8(%rcx,%rax), %rsi
testq %rsi, %rsi
movq %r14, %rbp
movl $0x0, %r14d
movq %r15, %r13
je 0xa2c9
addq %rax, %rcx
movq (%rcx), %rdi
movzbl 0x7(%rsp), %ecx
jmp 0xa401
cmpl $0x6f, %eax
jne 0xa40b
movl %ecx, %r14d
leaq 0x28(%rbp), %rsi
addq $-0x2, %r12
movq %r12, 0x8(%rbx)
addq $0x50, %rbp
movq %rbp, (%rbx)
movq %r13, %rdi
callq 0xabe1
cmpq $-0x1, %rax
je 0xa42b
movq 0x28(%r13), %rcx
imulq $0x38, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x10, %rdi
movzbl %r14b, %ecx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0xa22c
movq %rax, %rbx
decq 0x8(%rbx)
movq (%rbx), %r14
leaq 0x28(%r14), %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x933f(%rip), %rdi      # 0x13771
leaq 0x9317(%rip), %rsi      # 0x13750
leaq 0x9315(%rip), %rcx      # 0x13755
movl $0xb8, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
cmpl $0x4, (%rsi)
jne 0xac29
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0xac29
movq 0x18(%r15), %rax
movq (%rax,%r13), %rdi
movq 0x20(%r14), %rsi
callq 0x3140
testl %eax, %eax
je 0xac26
incq %rbp
addq $0x10, %r13
jmp 0xac03
movq %rbp, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop