LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/error.c
// Function: die
extern void die(const char * const restrict s, ...)
{
	int ex = errno;
	char *d = NULL;
	va_list ap;
	va_start(ap, s);
#ifndef _WIN32
	vasprintf(&d, s, ap);
#else
	uint8_t l = 0xFF;
	if ((d = calloc(l, sizeof l)))
		vsnprintf(d, l - 1, s, ap);
#endif
	fprintf(stderr, "%s", d);
	va_end(ap);
	fprintf(stderr, "\n");
#ifdef BUILD_GUI
	error_gui_alert(d);
#endif
	free(d);
	if (ex)
	{
		char * const restrict e = strdup(strerror(ex));
		for (uint32_t i = 0; e && i < strlen(e); i++)
			e[i] = tolower((unsigned char)e[i]);
		fprintf(stderr, "%s\n", e);
		free(e);
#if !defined _WIN32 && !defined __CYGWIN__ && !defined __FreeBSD__
		void *bt[BACKTRACE_BUFFER_LIMIT];
		int c = backtrace(bt, BACKTRACE_BUFFER_LIMIT);
		char **sym = backtrace_symbols(bt, c);
		if (sym)
		{
			for (int i = 0; i < c; i++)
				fprintf(stderr, "%s\n", sym[i]);
			free(sym);
		}
#endif
	}
	exit(ex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp           # imm = 0x20E8
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x3874
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)
callq 0x2060
movl (%rax), %ebx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
leaq 0x10(%rsp), %rdx
movq %r12, 0x10(%rdx)
leaq 0x2120(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0x473d(%rip), %r12      # 0x7ff8
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x2170
movq (%r12), %rsi
movl $0xa, %edi
callq 0x21b0
movq (%r15), %rdi
callq 0x2050
testl %ebx, %ebx
je 0x39ab
movl %ebx, %edi
callq 0x2380
movq %rax, %rdi
callq 0x2370
movq %rax, %r14
testq %rax, %rax
je 0x3933
cmpb $0x0, (%r14)
je 0x3933
movl $0x1, %ebp
xorl %r13d, %r13d
callq 0x23c0
movq %rax, %r15
movq (%r15), %rax
movzbl (%r14,%r13), %ecx
movb (%rax,%rcx,4), %al
movb %al, (%r14,%r13)
movl %ebp, %r13d
movq %r14, %rdi
callq 0x2100
incl %ebp
cmpq %r13, %rax
ja 0x3912
movq (%r12), %rdi
leaq 0x1a03(%rip), %rsi      # 0x5341
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
movq %r14, %rdi
callq 0x2050
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x2110
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x20d0
testq %rax, %rax
je 0x39ab
movq %rax, %r14
testl %ebp, %ebp
jle 0x39a3
movl %ebp, %r13d
leaq 0x19ba(%rip), %r15      # 0x5341
xorl %ebp, %ebp
movq (%r12), %rdi
movq (%r14,%rbp,8), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
incq %rbp
cmpq %rbp, %r13
jne 0x3989
movq %r14, %rdi
callq 0x2050
movl %ebx, %edi
callq 0x2340
nop
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_print
static int cli_print(FILE *stream, const char *text)
{
	size_t l = strlen(text);
	char *copy = m_calloc(1, l + 1);
#ifndef _WIN32
	bool strip = !((stream == stdout && isatty(STDOUT_FILENO)) || (stream == stderr && isatty(STDERR_FILENO)));
#else
	#ifdef __DEBUG__
	bool strip = cli_inited != 1;
	#else
	bool strip = false;
	#endif
#endif
	if (strip)
	{
		char *ptr = (char *)text;
		for (size_t i = 0, j = 0; i < l; i++)
		{
			char *e = strstr(ptr, "\x1b[");
			if (!e)
				break;
			memcpy(copy + j, ptr, e - ptr);
			j += e - ptr;
			ptr = strchr(e, 'm') + 1;
		}
		strcat(copy, ptr);
	}
	else
		strcpy(copy, text);
	int x = fprintf(stream, "%s", copy);
	//fprintf(stream, "\n");
	free(copy);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r12
leaq 0x1(%rax), %r8
leaq 0x183f(%rip), %rdi      # 0x5345
leaq 0x18fa(%rip), %rdx      # 0x5407
movl $0x1, %ecx
movl $0x16a, %esi            # imm = 0x16A
callq 0x434b
movq %rax, %r14
movq 0x44b2(%rip), %rax      # 0x7fd8
cmpq %rbx, (%rax)
je 0x3b9b
movq 0x44c6(%rip), %rax      # 0x7ff8
cmpq %rbx, (%rax)
je 0x3bab
movq %rbx, (%rsp)
testq %r12, %r12
je 0x3b8a
xorl %r13d, %r13d
movq %r15, %rdi
leaq 0x18c4(%rip), %rsi      # 0x5411
callq 0x23b0
testq %rax, %rax
je 0x3b8a
movq %rax, %rbx
leaq (%r14,%r13), %rdi
movq %rax, %rbp
subq %r15, %rbp
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2220
addq %rbp, %r13
movq %rbx, %rdi
movl $0x6d, %esi
callq 0x2130
movq %rax, %r15
incq %r15
decq %r12
jne 0x3b43
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
movq (%rsp), %rbx
jmp 0x3bc8
movl $0x1, %edi
callq 0x20c0
testl %eax, %eax
jne 0x3bbd
jmp 0x3b2b
movl $0x2, %edi
callq 0x20c0
testl %eax, %eax
je 0x3b37
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
leaq 0x15f2(%rip), %rsi      # 0x51c1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2210
movl %eax, %ebx
movq %r14, %rdi
callq 0x2050
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_eprintf
extern int cli_eprintf(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(stderr, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3c42
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 %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x45e6(%rip)      # 0x8248
jne 0x3c69
callq 0x3a8d
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x434a(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x3adf
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: logger
extern int logger(const char * const restrict s, ...)
{
	CLI_DO_INIT;

	int x = 0;
#if 0
	time_t now = time(NULL);
	char at[24];
	struct tm t;
	localtime_r(&now, &t);
	strftime(at, sizeof at, "%F %T : ", &t);
	x += cli_print(stderr, at);
#endif
	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	x += cli_print(stderr, d);
	va_end(ap);
	free(d);

	static const char nl[] = "\n";
	x += cli_print(stderr, nl);

	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x3d1d
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 %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x450b(%rip)      # 0x8248
jne 0x3d44
callq 0x3a8d
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq 0x426f(%rip), %r15      # 0x7ff8
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x3adf
movl %eax, %ebx
movq (%r14), %rdi
callq 0x2050
movq (%r15), %rdi
leaq 0x158c(%rip), %rsi      # 0x5334
callq 0x3adf
addl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintf
extern int cli_fprintf(FILE *f, const char * const restrict s, ...)
{
	CLI_DO_INIT;

	va_list ap;
	va_start(ap, s);
	char *d = NULL;
	vasprintf(&d, s, ap);
	int x = cli_print(f, d);
	va_end(ap);
	free(d);
	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb %al, %al
je 0x3e0c
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 %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
cmpb $0x0, 0x4421(%rip)      # 0x8248
jne 0x3e2e
callq 0x3a8d
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x3adf
movl %eax, %ebx
movq (%r15), %rdi
callq 0x2050
movl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_fprintx
extern int cli_fprintx(FILE *f, const uint8_t * const restrict x, size_t z)
{
	CLI_DO_INIT;

#define CLI_PRINTX_W 16
	// TODO allow variable width lines
	int l = 0, o = 0;
	char r[CLI_PRINTX_W * 2 + CLI_PRINTX_W] = { 0x0 };
	for (size_t i = 0; i < z; i++)
	{
		char c[4] = { 0x0 };
		sprintf(c, "%02x", x[i]);
		strcat(r, c);
		if (i % 2 == 1)
			strcat(r, " ");
		if (i % CLI_PRINTX_W == (CLI_PRINTX_W - 1))
		{
			l += cli_fprintf(f, "%08x: %s\n", o, r);
			memset(r, 0x00, sizeof r);
			o += CLI_PRINTX_W;
		}
	}
	if (strlen(r))
		l += cli_fprintf(f, "%08x: %s\n", o, r);
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
cmpb $0x0, 0x4362(%rip)      # 0x8248
jne 0x3eed
callq 0x3a8d
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
testq %r14, %r14
je 0x3fc9
leaq 0xc(%rsp), %rbx
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax,%r15), %edx
movq %rbx, %rdi
leaq 0x1400(%rip), %rsi      # 0x5336
xorl %eax, %eax
callq 0x2330
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2320
testb $0x1, %r15b
je 0x3f5d
movq %r13, %rdi
callq 0x2100
movw $0x20, 0x20(%rsp,%rax)
movl %r15d, %eax
notl %eax
testb $0xf, %al
jne 0x3f97
movq 0x10(%rsp), %rdi
leaq 0x13c9(%rip), %rsi      # 0x533b
movl %r12d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3dbc
addl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
addl $0x10, %r12d
incq %r15
cmpq %r15, %r14
jne 0x3f1a
cmpb $0x0, 0x20(%rsp)
je 0x3fcb
leaq 0x138a(%rip), %rsi      # 0x533b
leaq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3dbc
addl %eax, %ebp
jmp 0x3fcb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_calc_bps
extern double cli_calc_bps(cli_bps_s *bps)
{
	CLI_DO_INIT;

	cli_bps_s *copy = m_calloc(BPS, sizeof( cli_bps_s ));
	for (int i = 0; i < BPS; i++)
	{
		copy[i].time  = bps[i].time;
		copy[i].bytes = bps[i].bytes;
	}
	qsort(copy, BPS, sizeof( cli_bps_s ), cli_bps_sort);
	double avg[BPS - 1] = { 0.0f };
	for (int i = 0; i < BPS - 1; i++)
		/*
		 * requires scale factor of MILLION as time is in microseconds
		 * not seconds (millions of bytes / micros of seconds, so to
		 * speak)
		 */
		avg[i] = MILLION * (double)(copy[i + 1].bytes - copy[i].bytes) / (double)(copy[i + 1].time - copy[i].time);
	double val = 0.0;
	for (int i = 0; i < BPS - 1; i++)
		val += avg[i];
	free(copy);
	return val /= (BPS - 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %r14
cmpb $0x0, 0x4224(%rip)      # 0x8248
jne 0x402b
callq 0x3a8d
leaq 0x1313(%rip), %rdi      # 0x5345
leaq 0x131d(%rip), %rdx      # 0x5356
movl $0x80, %ecx
movl $0x10, %r8d
movl $0xbd, %esi
callq 0x434b
movq %rax, %rbx
xorl %eax, %eax
movups (%r14,%rax), %xmm0
movups %xmm0, (%rbx,%rax)
addq $0x10, %rax
cmpq $0x800, %rax            # imm = 0x800
jne 0x4053
leaq 0xea(%rip), %rcx        # 0x4159
movl $0x80, %esi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
movl $0x3f8, %edx            # imm = 0x3F8
xorl %esi, %esi
callq 0x2180
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movl $0xc, %eax
movq 0x11ea(%rip), %xmm0     # 0x5290
movapd 0x11f2(%rip), %xmm1     # 0x52a0
movsd 0x120a(%rip), %xmm2     # 0x52c0
movq -0x8(%rbx,%rax,2), %rsi
movq (%rbx,%rax,2), %rdx
movq %rdx, %r8
subq %rdi, %r8
movq %r8, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
mulsd %xmm2, %xmm4
movq %rsi, %rdi
subq %rcx, %rdi
movq %rdi, %xmm3
punpckldq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5            # xmm5 = xmm5[1],xmm3[1]
addsd %xmm3, %xmm5
divsd %xmm5, %xmm4
movsd %xmm4, 0x4(%rsp,%rax)
addq $0x8, %rax
movq %rsi, %rcx
movq %rdx, %rdi
cmpq $0x404, %rax            # imm = 0x404
jne 0x40b6
pxor %xmm0, %xmm0
xorl %eax, %eax
addsd 0x10(%rsp,%rax,8), %xmm0
incq %rax
cmpq $0x7f, %rax
jne 0x4123
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2050
movsd 0x8(%rsp), %xmm0
divsd 0x117a(%rip), %xmm0     # 0x52c8
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: cli_display_bars
static void cli_display_bars(cli_progress_s *t, cli_progress_s *c, cli_bps_s *bps)
{
	double total   = PERCENT * (t->offset + (1.0f * c->offset / c->size)) / t->size;
	double current = PERCENT * c->offset / c->size;
	bool single = t->size == 1;

	if (!single)
	{
		char name[CLI_TRUNCATED_DISPLAY_LONG] = { 0x0 };
		char *nm = c->display ? /*dir_get_name(c->display, '.')*/ : CLI_UNKNOWN;
		if (strlen(nm) < CLI_TRUNCATED_DISPLAY_LONG)
			strcpy(name, nm);
		else
		{
			strncpy(name, nm, CLI_TRUNCATED_DISPLAY_SHORT);
			strcat(name, CLI_TRUNCATED_ELLIPSE);
			if (cli_width > CLI_DEFAULT)
				strcat(name, nm + (strlen(nm) - CLI_TRUNCATED_DISPLAY_SHORT));
		}
		fprintf(stderr, "\x1B[1F"); // go up 1 line
		cli_display_bar(name, c, current);
		cli_display_bps(bps);
		fprintf(stderr, "\n");
	}
	cli_display_bar("Total", single ? c : t, total);

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
testq %rcx, %rcx
js 0x41c6
cvtsi2ss %rcx, %xmm1
jmp 0x41db
movq %rcx, %rdi
shrq %rdi
andl $0x1, %ecx
orq %rdi, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
movq 0x8(%rbx), %r14
testq %rax, %rax
js 0x41eb
cvtsi2ss %rax, %xmm2
jmp 0x4200
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
movq (%rbx), %r15
cmpq $0x1, %r14
jne 0x420e
movq %rsi, %rbx
jmp 0x4245
movss 0x111a(%rip), %xmm0     # 0x5330
mulss %xmm1, %xmm0
divss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rsi, %rdi
movq %rdx, %rsi
movss %xmm1, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
callq 0x27b1
movss 0x8(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
divss %xmm2, %xmm1
testq %r15, %r15
js 0x4258
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
jmp 0x4271
movq %r15, %rax
shrq %rax
andl $0x1, %r15d
orq %rax, %r15
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
addss %xmm0, %xmm0
addss %xmm0, %xmm1
mulss 0x10b3(%rip), %xmm1     # 0x5330
testq %r14, %r14
js 0x428c
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
jmp 0x42a5
movq %r14, %rax
shrq %rax
andl $0x1, %r14d
orq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
addss %xmm0, %xmm0
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x10c8(%rip), %rdi      # 0x537f
movq %rbx, %rsi
callq 0x267c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/albinoloverats[P]hide/common/src/cli.c
// Function: on_quit
extern void on_quit(int s)
{
	fprintf(stderr, "\e[?25h\n"); /* restore cursor */
	signal(s, SIG_DFL);
	raise(s);
	_exit(EXIT_FAILURE); // this shouldn't happen as the raise above will handle things
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x3d25(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0xf63(%rip), %rdi       # 0x5240
movl $0x7, %esi
movl $0x1, %edx
callq 0x2350
movl %ebx, %edi
xorl %esi, %esi
callq 0x21f0
movl %ebx, %edi
callq 0x2040
movl $0x1, %edi
callq 0x2090
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4332
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10db(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/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 0x4378
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1095(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/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 0x43be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x104f(%rip), %rdi      # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/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 0x440b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1002(%rip), %rdi      # 0x5414
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/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 0x4467
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r12
cmovaq %r12, %rbx
leaq 0xf9f(%rip), %rdi       # 0x5414
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]cproc/util.c
// Function: vwarn
static void
vwarn(const char *fmt, va_list ap)
{
	fprintf(stderr, "%s: ", argv0);
	vfprintf(stderr, fmt, ap);
	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x17d62(%rip), %r15     # 0x1aff8
movq (%r15), %rdi
movq 0x18e98(%rip), %rdx     # 0x1c138
leaq 0x124aa(%rip), %rsi     # 0x15751
xorl %eax, %eax
callq 0x3160
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3200
cmpb $0x0, (%rbx)
je 0x32d0
movq %rbx, %rdi
callq 0x3090
cmpb $0x3a, -0x1(%rbx,%rax)
je 0x32e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3110
movq (%r15), %rsi
pushq $0x20
popq %rdi
callq 0x3110
xorl %edi, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x31f0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x18cea(%rip), %rax     # 0x1c108
cmpl $0x40, (%rax)
jne 0x3479
movl %esi, %ebx
movq %rdi, %r14
movl $0x40, %edi
callq 0xaf24
testb %al, %al
je 0x3479
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x355b
testb %al, %al
jne 0x3436
movl $0x6e, %edi
callq 0xb00a
testb %al, %al
jne 0x3436
leaq 0xeba9(%rip), %rbx      # 0x12004
movl $0x41, %edi
movq %rbx, %rsi
callq 0xafeb
movl $0x41, %edi
movq %rbx, %rsi
callq 0xafeb
movb $0x1, %al
jmp 0x347b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x3f, %edi
callq 0xb00a
movl %eax, %ebx
testb %al, %al
je 0x354e
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x355b
testb %al, %al
jne 0x34ca
movl $0x6e, %edi
callq 0xb00a
testb %al, %al
jne 0x34ca
leaq 0xebc1(%rip), %r15      # 0x120b3
movl $0x42, %edi
movq %r15, %rsi
callq 0xafeb
movl $0x42, %edi
movq %r15, %rsi
callq 0xafeb
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x355b
testb %al, %al
jne 0x350c
movl $0x6e, %edi
callq 0xb00a
testb %al, %al
jne 0x350c
leaq 0xead0(%rip), %r14      # 0x12004
movl $0x43, %edi
movq %r14, %rsi
callq 0xafeb
movl $0x43, %edi
movq %r14, %rsi
callq 0xafeb
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37dd
cmpb $0x5f, (%rbx)
jne 0x37dd
cmpb $0x5f, 0x1(%rbx)
jne 0x37dd
cmpb $0x5f, -0x2(%rbx,%rax)
jne 0x37dd
cmpb $0x5f, -0x1(%rbx,%rax)
jne 0x37dd
movb $0x0, -0x2(%rbx,%rax)
addq $0x2, %rbx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x48, %edi
callq 0xe142
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 0x383d
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_O3/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 0x38e3
cmpq $0x0, (%r12)
je 0x38d2
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x48fe
movq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
testq %r14, %r14
je 0x38c5
movl 0x28(%rsp), %eax
orl %eax, (%r14)
testq %rbx, %rbx
je 0x38d2
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_O3/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
movl $0x28, %edi
callq 0xb00a
movl %eax, %ebx
testb %al, %al
je 0x5200
leaq 0xdd59(%rip), %rsi      # 0x12ea4
movl $0x42, %edi
callq 0xafeb
movq %r14, %rdi
movl $0x1, %esi
callq 0x7359
movq %rax, %r15
movl $0x6e, %edi
callq 0xb00a
testb %al, %al
je 0x51c1
leaq 0x16f8e(%rip), %r14     # 0x1c108
leaq 0xdd37(%rip), %rdx      # 0x12eb8
movq %r14, %rdi
movl $0x7, %esi
callq 0xd3c5
movq %rsp, %rdi
movl $0x1, %esi
callq 0x69eb
testq %r15, %r15
jne 0x51df
movl (%rsp), %edx
decl %edx
movq 0x8(%rsp), %rcx
addq $0x8, %r14
leaq 0xdd25(%rip), %rsi      # 0x12eda
movq %r14, %rdi
xorl %eax, %eax
callq 0xd55c
jmp 0x51df
testq %r15, %r15
jne 0x51df
leaq 0x16f3b(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xdd20(%rip), %rsi      # 0x12ef8
xorl %eax, %eax
callq 0xd55c
leaq 0xdd2a(%rip), %r14      # 0x12f10
movl $0x43, %edi
movq %r14, %rsi
callq 0xafeb
movl $0x61, %edi
movq %r14, %rsi
callq 0xafeb
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x55bf
movq (%rbx), %rdx
leaq 0x16b5f(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xda1b(%rip), %rsi      # 0x12fcf
xorl %eax, %eax
callq 0xd55c
movq 0x10(%rbx), %rax
movl 0x8(%rax), %eax
cmpl %eax, 0x40(%rbx)
jge 0x55ca
movl %eax, 0x40(%rbx)
cmpl $0x2, 0x44(%rbx)
jne 0x55e4
movzbl %bpl, %ecx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x103e2
jmp 0x55ef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10ff3
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x16974(%rip)     # 0x1bf88
jne 0x5627
leaq 0x1696b(%rip), %rdi     # 0x1bf88
movl $0x40, %esi
callq 0xa52f
cmpl $0x2, (%rbx)
jne 0x56de
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa500
leaq 0x1693e(%rip), %rdi     # 0x1bf88
movq %r14, %rsi
callq 0xa6a0
movq (%rax), %r15
testq %r15, %r15
jne 0x56cf
movq %rax, %r14
movq 0x8(%rbx), %r12
movl $0x48, %edi
callq 0xe142
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
leaq 0xcf17(%rip), %rax      # 0x1259b
movq %rax, (%r15)
movq $0x1, 0x8(%r15)
movq %r12, 0x10(%r15)
testq %r12, %r12
je 0x56a1
movl 0x8(%r12), %eax
movl %eax, 0x40(%r15)
movq %r15, %rdi
callq 0xe324
movq %rax, 0x20(%r15)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
xorl %edi, %edi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x9940
movq %r15, %rdi
movq %rax, %rsi
callq 0x10ff3
movq %r15, (%r14)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1042e(%rip), %rdi     # 0x15b13
leaq 0xce3f(%rip), %rsi      # 0x1252b
leaq 0xce81(%rip), %rcx      # 0x12574
movl $0x46c, %edx            # imm = 0x46C
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x168a3(%rip), %rbx     # 0x1bfa8
testq %rbx, %rbx
je 0x5724
cmpb $0x0, 0x30(%rbx)
jne 0x571e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5583
movq 0x38(%rbx), %rbx
jmp 0x5705
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x169da(%rip), %rax     # 0x1c108
movl (%rax), %ecx
xorl %ebx, %ebx
cmpl $0x32, %ecx
jg 0x5748
cmpl $0xf, %ecx
je 0x5759
cmpl $0x22, %ecx
jne 0x5783
movl $0x4, %eax
jmp 0x575e
cmpl $0x35, %ecx
je 0x576c
cmpl $0x33, %ecx
jne 0x5783
movl $0x8, %eax
jmp 0x575e
movl $0x2, %eax
orl %eax, (%rdi)
callq 0xa920
movl $0x1, %ebx
jmp 0x5783
addq $0x8, %rax
leaq 0xcfbc(%rip), %rsi      # 0x12733
xorl %ebx, %ebx
movq %rax, %rdi
xorl %eax, %eax
callq 0xd55c
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6460
testb $0x2, %cl
je 0x645f
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 0x645f
decb %al
movl $0x1, %edx
movl %eax, %ecx
shlq %cl, %rdx
btcq %rax, %rsi
subq %rdx, %rsi
movq %rsi, 0x30(%rdi)
retq
cmpl $0x4, %eax
jne 0x645f
cvtsd2ss 0x30(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6959
movq 0x8(%rdi), %rcx
movl (%rcx), %edx
movb $0x1, %al
cmpl $0x11, %edx
je 0x695b
testb $0x2, 0x4(%rcx)
jne 0x695c
cmpl $0xc, %edx
jne 0x6959
movq 0x20(%rcx), %rax
cmpq 0x14649(%rip), %rax     # 0x1afa0
je 0x695c
xorl %eax, %eax
retq
cmpq $0x0, 0x30(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
jne 0x71bb
movq %r14, %rdi
callq 0x7e09
movq %rax, %r15
leaq 0x14f46(%rip), %rbx     # 0x1c108
movl (%rbx), %ebp
movl %ebp, %edi
callq 0x8010
cmpl %r12d, %eax
jl 0x7240
movl %eax, %r13d
movl %r12d, 0xc(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x20(%rsp)
movups 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
callq 0xa920
movq %r14, %rdi
callq 0x7e09
movq %rax, %r12
movl (%rbx), %edi
callq 0x8010
cmpl %r13d, %eax
jle 0x7215
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x7194
jmp 0x71f7
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7787
movq %rax, %r15
movl (%rbx), %ebp
movl %ebp, %edi
callq 0x8010
movl %eax, %r13d
movl 0xc(%rsp), %r12d
cmpl %r12d, %eax
jge 0x71d8
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_O3/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, %r14
callq 0x73d0
movq %rax, %rbx
leaq 0x14e9c(%rip), %r15     # 0x1c108
cmpl $0x6e, (%r15)
jne 0x7290
movq %rbx, %r12
callq 0xa920
movq %r14, %rdi
callq 0x73d0
movq %rax, 0x20(%r12)
cmpl $0x6e, (%r15)
movq %rax, %r12
je 0x7275
cmpq $0x0, 0x20(%rbx)
je 0x72ca
movq 0x8(%rax), %r14
movl $0x40, %edi
callq 0xe142
movl $0x0, 0x10(%rax)
movq %r14, 0x8(%rax)
movw $0x0, 0x4(%rax)
movl $0xc, (%rax)
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x4, (%rax)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jne 0x730c
movl 0x10(%rdi), %esi
shll $0x3, %esi
movswl 0x30(%rax), %edx
movswl 0x32(%rax), %eax
addl %edx, %eax
subl %eax, %esi
movq (%rbx), %rax
movq 0x8(%rax), %rdx
cmpl $0x4, (%rax)
jne 0x732c
movl 0x10(%rdx), %ecx
shll $0x3, %ecx
movswl 0x30(%rax), %r8d
movswl 0x32(%rax), %eax
addl %r8d, %eax
subl %eax, %ecx
callq 0xdac2
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6965
movq %rax, (%r14)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6965
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6f6b
movq %rax, %rdi
callq 0x603c
movq %rax, %rbx
cmpl $0x1, (%rax)
jne 0x737d
movq 0x8(%rbx), %rax
testb $0x2, 0x4(%rax)
jne 0x7396
leaq 0x14d84(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc31a(%rip), %rsi      # 0x136a9
xorl %eax, %eax
callq 0xd55c
testb %bpl, %bpl
jne 0x73c5
movq 0x8(%rbx), %rax
cmpb $0x1, 0x40(%rax)
jne 0x73c5
cmpq $0x0, 0x30(%rbx)
jns 0x73c5
leaq 0x14d55(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc30e(%rip), %rsi      # 0x136cc
xorl %eax, %eax
callq 0xd55c
movq 0x30(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x4b, %edi
je 0x76e1
movl %edi, %esi
cmpl $0x4a, %edi
jne 0x7720
cmpb $0x1, 0x5(%rbx)
jne 0x764c
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3250
movq %r14, %rbx
cmpb $0x0, 0x4(%rbx)
jne 0x7679
movq 0x8(%rbx), %rax
movl (%rax), %eax
addl $-0xe, %eax
cmpl $0x3, %eax
jb 0x7679
leaq 0x14aa1(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xca6a(%rip), %rsi      # 0x140dc
xorl %eax, %eax
callq 0xd55c
cmpl $0x4, (%rbx)
jne 0x7697
leaq 0x14a83(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xca80(%rip), %rsi      # 0x14110
xorl %eax, %eax
callq 0xd55c
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0xd803
movq %rax, %r15
movl $0x40, %edi
callq 0xe142
movq %rax, %r14
movabsq $0x4a00000000, %rax     # imm = 0x4A00000000
movq %rax, 0x10(%r14)
movq %r15, 0x8(%r14)
movw $0x0, 0x4(%r14)
movl $0x7, (%r14)
movq %rbx, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
jmp 0x7731
movq 0x8(%rbx), %rax
cmpl $0xc, (%rax)
je 0x7703
leaq 0x14a17(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xca35(%rip), %rsi      # 0x14131
xorl %eax, %eax
callq 0xd55c
cmpl $0x7, (%rbx)
jne 0x773a
cmpl $0x4a, 0x14(%rbx)
movq 0x8(%rbx), %rax
jne 0x773e
movq 0x20(%rax), %rax
movq 0x18(%rbx), %rdi
movq %rax, 0x8(%rdi)
jmp 0x777d
leaq 0xca29(%rip), %rdi      # 0x14150
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xe058
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
movq 0x20(%rax), %r14
movl $0x40, %edi
callq 0xe142
movq %rax, %rdi
movq %r14, 0x8(%rax)
movb $0x0, 0x5(%rax)
movl $0x7, (%rax)
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq 0x8(%rbx), %rax
movl 0x38(%rax), %eax
movl %eax, 0x10(%rdi)
movb $0x1, 0x4(%rdi)
movl $0x4b, 0x14(%rdi)
popq %rbx
popq %r14
popq %r15
jmp 0x92c1
// File: /workspace/github_c_makefile_star2_O3/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 0x9301
cmpl $0xd, %eax
jne 0x9315
movl 0x10(%rbx), %ebp
movl $0x4a, %edi
movq %rbx, %rsi
callq 0x761b
movq %rax, %rbx
movq 0x20(%r14), %rdi
orl 0x38(%r14), %ebp
movl %ebp, %esi
callq 0xd803
movq %rax, 0x8(%rbx)
jmp 0x9311
movl $0x4a, %edi
movq %rbx, %rsi
callq 0x761b
movq %rax, %rbx
movb $0x1, 0x5(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x97cc
leaq 0x11e61(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x1294e(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa767(%rip), %rsi      # 0x13f2c
xorl %eax, %eax
callq 0xd55c
testb $0x2, 0x10(%r14)
je 0x97f7
leaq 0x11e36(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x12923(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa767(%rip), %rsi      # 0x13f57
xorl %eax, %eax
callq 0xd55c
movq 0x8(%r14), %r15
movl $0x40, %edi
callq 0xe142
movl $0x0, 0x10(%rax)
movq %r15, 0x8(%rax)
movw $0x0, 0x4(%rax)
movl $0x5, (%rax)
movq %r14, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
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_O3/michaelforney[P]cproc/expr.c
// Function: inttype
static struct type *
inttype(unsigned long long val, bool decimal, char *end)
{
	static struct {
		struct type *type;
		const char *end1, *end2;
	} limits[] = {
		{&typeint,    "",    NULL},
		{&typeuint,   "u",   NULL},
		{&typelong,   "l",   NULL},
		{&typeulong,  "ul",  "lu"},
		{&typellong,  "ll",  NULL},
		{&typeullong, "ull", "llu"},
	};
	struct type *t;
	size_t i, step;

	for (i = 0; end[i]; ++i)
		end[i] = tolower(end[i]);
	for (i = 0; i < LEN(limits); ++i) {
		if (strcmp(end, limits[i].end1) == 0)
			break;
		if (limits[i].end2 && strcmp(end, limits[i].end2) == 0)
			break;
	}
	if (i == LEN(limits))
		error(&tok.loc, "invalid integer constant suffix '%s'", end);
	step = i % 2 || decimal ? 2 : 1;
	for (; i < LEN(limits); i += step) {
		t = limits[i].type;
		if (typehasint(t, val, false))
			return t;
	}
	error(&tok.loc, "no suitable type for constant '%s'", tok.lit);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movb (%rdx), %r15b
testb %r15b, %r15b
je 0x9874
callq 0x3230
leaq 0x1(%r14), %rcx
movq (%rax), %rdx
movsbq %r15b, %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %r15b
incq %rcx
testb %r15b, %r15b
jne 0x985c
leaq 0x10d25(%rip), %r15     # 0x1a5a0
xorl %r12d, %r12d
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3140
testl %eax, %eax
je 0x98ce
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x98a3
movq %r14, %rdi
callq 0x3140
testl %eax, %eax
je 0x98ce
incq %r12
addq $0x18, %r15
cmpq $0x6, %r12
jne 0x987e
leaq 0x12851(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa239(%rip), %rsi      # 0x13afb
movq %r14, %rdx
xorl %eax, %eax
callq 0xd55c
jmp 0x990e
cmpq $0x5, %r12
ja 0x990e
orb %r12b, %bpl
movzbl %bpl, %r13d
andl $0x1, %r13d
incq %r13
leal (,%r13,8), %eax
leaq (%rax,%rax,2), %rbp
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xdd39
testb %al, %al
jne 0x992e
addq %r13, %r12
addq %rbp, %r15
cmpq $0x5, %r12
jbe 0x98ee
leaq 0x127f3(%rip), %rdi     # 0x1c108
movq 0x20(%rdi), %rdx
addq $0x8, %rdi
leaq 0xa1fc(%rip), %rsi      # 0x13b20
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xd55c
movq %r14, %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/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
movl $0x28, %edi
callq 0xe142
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl %ebp, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq