LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x21a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x570f
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x56ea
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x56f2
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rcx
movl -0x44(%rbp), %edx
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %r8
leaq 0xd3f(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x575e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2100
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x28, (%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x20f0
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rax
cmpl $0x0, -0x2c(%rbp)
jge 0x57eb
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0xc63(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movl -0x2c(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/common/src/mem.c
// Function: mem_fod
extern char *mem_fod(const char *file, int line, const char *func, const char *template, ...)
{
	int r = 0;
	size_t l = strlen(template);
	va_list ap;
	va_start(ap, template);

	char *ptr = NULL;
#ifndef _WIN32
	r = vasprintf(&ptr, template, ap);
#else
	ptr = mem_cod(file, line, func, l, VSN_SIZE);
	l *= VSN_SIZE;
	r = vsnprintf(ptr, l - 1, template, ap);
#endif
	va_end(ap);
	if (r < 0)
		die(_("Out of memory @ %s:%d:%s [%zu]"), file, line, func, l);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x5841
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x20f0
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
jge 0x58d9
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xb75(%rip), %rdi       # 0x6447
movb $0x0, %al
callq 0x3ed0
movq -0x58(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/attr.c
// Function: attr
bool
attr(struct attr *a, enum attrkind allowed)
{
	if (!attrspec(a, allowed))
		return false;
	while (attrspec(a, allowed))
		;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x33b0
testb $0x1, %al
jne 0x3385
movb $0x0, -0x1(%rbp)
jmp 0x339f
jmp 0x3387
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x33b0
testb $0x1, %al
jne 0x3399
jmp 0x339b
jmp 0x3387
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x1ede2(%rip), %rax     # 0x221a8
cmpl $0x40, (%rax)
jne 0x33d9
movl $0x40, %edi
callq 0xd7b0
testb $0x1, %al
jne 0x33df
movb $0x0, -0x1(%rbp)
jmp 0x3439
jmp 0x33e1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x3590
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x3408
movl $0x6e, %edi
callq 0xd910
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x3411
jmp 0x3413
jmp 0x33e1
movl $0x41, %edi
leaq 0x14be5(%rip), %rsi     # 0x18004
callq 0xd8d0
movl $0x41, %edi
leaq 0x14bd4(%rip), %rsi     # 0x18004
callq 0xd8d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/attr.c
// Function: gnuattr
bool
gnuattr(struct attr *a, enum attrkind allowed)
{
	if (!gnuattrspec(a, allowed))
		return false;
	while (gnuattrspec(a, allowed))
		;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x34a0
testb $0x1, %al
jne 0x3475
movb $0x0, -0x1(%rbp)
jmp 0x348f
jmp 0x3477
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x34a0
testb $0x1, %al
jne 0x3489
jmp 0x348b
jmp 0x3477
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x3f, %edi
callq 0xd910
testb $0x1, %al
jne 0x34c6
movb $0x0, -0x1(%rbp)
jmp 0x357a
jmp 0x34c8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x2, %edx
callq 0x3590
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x34f2
movl $0x6e, %edi
callq 0xd910
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x34fb
jmp 0x34fd
jmp 0x34c8
movl $0x42, %edi
leaq 0x14baa(%rip), %rsi     # 0x180b3
callq 0xd8d0
movl $0x42, %edi
leaq 0x14b99(%rip), %rsi     # 0x180b3
callq 0xd8d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x2, %edx
callq 0x3590
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x16(%rbp)
jne 0x3549
movl $0x6e, %edi
callq 0xd910
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x3552
jmp 0x3554
jmp 0x351f
movl $0x43, %edi
leaq 0x14aa4(%rip), %rsi     # 0x18004
callq 0xd8d0
movl $0x43, %edi
leaq 0x14a93(%rip), %rsi     # 0x18004
callq 0xd8d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq %rax, -0x10(%rbp)
cmpq $0x4, -0x10(%rbp)
jb 0x38af
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x38af
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5f, %eax
jne 0x38af
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x38af
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x38af
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x2, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x48, %edi
callq 0x127c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x48, %edx
callq 0x3110
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
cmpl $0x1, -0xc(%rbp)
jne 0x3948
cmpq $0x0, -0x18(%rbp)
je 0x3948
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x3a30
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3a21
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rax
xorl %ecx, %ecx
movl $0x1, %r8d
movq (%rax), %rdx
movq %rdx, (%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq %rcx, %rdx
callq 0x42f0
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a0d
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x3a1f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3a21
movq -0x30(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x28, %edi
callq 0xd910
testb $0x1, %al
jne 0x4f33
movb $0x0, -0x1(%rbp)
jmp 0x5004
movl $0x42, %edi
leaq 0x14091(%rip), %rsi     # 0x18fd0
callq 0xd8d0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x90c0
movq %rax, -0x28(%rbp)
movl $0x6e, %edi
callq 0xd910
testb $0x1, %al
jne 0x4f66
jmp 0x4fbc
leaq 0x1d23b(%rip), %rdi     # 0x221a8
movl $0x7, %esi
leaq 0x1406b(%rip), %rdx     # 0x18fe4
callq 0x10f20
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x8390
cmpq $0x0, -0x28(%rbp)
jne 0x4fba
movq -0x20(%rbp), %rax
subq $0x1, %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
leaq 0x1d200(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x14053(%rip), %rsi     # 0x19006
movb $0x0, %al
callq 0x11190
jmp 0x4fde
cmpq $0x0, -0x28(%rbp)
jne 0x4fdc
leaq 0x1d1de(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x1404f(%rip), %rsi     # 0x19024
movb $0x0, %al
callq 0x11190
jmp 0x4fde
movl $0x43, %edi
leaq 0x14052(%rip), %rsi     # 0x1903c
callq 0xd8d0
movl $0x61, %edi
leaq 0x14041(%rip), %rsi     # 0x1903c
callq 0xd8d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0x3c(%rax)
je 0x53d9
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x1cde1(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x13d29(%rip), %rsi     # 0x190fb
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x53ff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5424
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x15ab0
jmp 0x5431
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x169a0
movq -0x8(%rbp), %rax
movb $0x1, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x1cbd4(%rip)     # 0x22028
jne 0x5467
leaq 0x1cbcb(%rip), %rdi     # 0x22028
movl $0x40, %esi
callq 0xd020
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x5472
jmp 0x5491
leaq 0x16e2e(%rip), %rdi     # 0x1c2a7
leaq 0x131d7(%rip), %rsi     # 0x18657
movl $0x46c, %edx            # imm = 0x46C
leaq 0x13214(%rip), %rcx     # 0x186a0
callq 0x30f0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x20(%rbp), %rdi
callq 0xcf70
leaq 0x1cb77(%rip), %rdi     # 0x22028
leaq -0x20(%rbp), %rsi
callq 0xd190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x554e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x131e8(%rip), %rdi     # 0x186c7
movl $0x1, %esi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x38c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x12c00
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movw $0x0, -0x34(%rbp)
movw $0x0, -0x32(%rbp)
movq -0x8(%rbp), %rcx
movl -0x34(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
callq 0xbe70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x169a0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1cad9(%rip), %rax     # 0x22048
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x55a6
movq -0x8(%rbp), %rax
testb $0x1, 0x30(%rax)
jne 0x5596
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x5390
jmp 0x5598
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5573
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1cbe5(%rip), %rax     # 0x221a8
movl (%rax), %eax
addl $-0xf, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x26, %eax
ja 0x5627
movq -0x18(%rbp), %rax
leaq 0x12bfa(%rip), %rcx     # 0x181d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x5630
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x5630
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x5630
leaq 0x1cb93(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x1323f(%rip), %rsi     # 0x1885f
movb $0x0, %al
callq 0x11190
movl $0x0, -0x4(%rbp)
jmp 0x563c
callq 0xd540
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/decl.c
// Function: storageclass
static int
storageclass(enum storageclass *sc)
{
	enum storageclass allowed, new;

	switch (tok.kind) {
	case TTYPEDEF:       new = SCTYPEDEF;     break;
	case TEXTERN:        new = SCEXTERN;      break;
	case TSTATIC:        new = SCSTATIC;      break;
	case TTHREAD_LOCAL:  new = SCTHREADLOCAL; break;
	case TAUTO:          new = SCAUTO;        break;
	case TREGISTER:      new = SCREGISTER;    break;
	default: return 0;
	}
	if (!sc)
		error(&tok.loc, "storage class not allowed in this declaration");
	switch (*sc) {
	case SCNONE:        allowed = ~SCNONE;           break;
	case SCTHREADLOCAL: allowed = SCSTATIC|SCEXTERN; break;
	case SCSTATIC:
	case SCEXTERN:      allowed = SCTHREADLOCAL;     break;
	default:            allowed = SCNONE;            break;
	}
	if (new & ~allowed)
		error(&tok.loc, "invalid combination of storage class specifiers");
	*sc |= new;
	next();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1cb45(%rip), %rax     # 0x221a8
movl (%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x23, %eax
ja 0x56bd
movq -0x20(%rbp), %rax
leaq 0x12bf6(%rip), %rcx     # 0x18274
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x18(%rbp)
jmp 0x56c9
movl $0x4, -0x18(%rbp)
jmp 0x56c9
movl $0x8, -0x18(%rbp)
jmp 0x56c9
movl $0x40, -0x18(%rbp)
jmp 0x56c9
movl $0x10, -0x18(%rbp)
jmp 0x56c9
movl $0x20, -0x18(%rbp)
jmp 0x56c9
movl $0x0, -0x4(%rbp)
jmp 0x5778
cmpq $0x0, -0x10(%rbp)
jne 0x56e9
leaq 0x1cad1(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x131a9(%rip), %rsi     # 0x1888b
movb $0x0, %al
callq 0x11190
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x5716
jmp 0x56f8
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0x5728
jmp 0x5702
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x5728
jmp 0x570c
movl -0x24(%rbp), %eax
subl $0x40, %eax
je 0x571f
jmp 0x5731
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x5738
movl $0xc, -0x14(%rbp)
jmp 0x5738
movl $0x40, -0x14(%rbp)
jmp 0x5738
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x5761
leaq 0x1ca59(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x1315f(%rip), %rsi     # 0x188b9
movb $0x0, %al
callq 0x11190
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
callq 0xd540
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/decl.c
// Function: funcspec
static int
funcspec(enum funcspec *fs)
{
	enum funcspec new;

	switch (tok.kind) {
	case TINLINE:    new = FUNCINLINE;   break;
	case T_NORETURN: new = FUNCNORETURN; break;
	default: return 0;
	}
	if (!fs)
		error(&tok.loc, "function specifier not allowed in this declaration");
	*fs |= new;
	next();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1ca05(%rip), %rax     # 0x221a8
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1d, %eax
je 0x57b9
jmp 0x57af
movl -0x18(%rbp), %eax
subl $0x3d, %eax
je 0x57c2
jmp 0x57cb
movl $0x2, -0x14(%rbp)
jmp 0x57d4
movl $0x4, -0x14(%rbp)
jmp 0x57d4
movl $0x0, -0x4(%rbp)
jmp 0x580b
cmpq $0x0, -0x10(%rbp)
jne 0x57f4
leaq 0x1c9c6(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x130fc(%rip), %rsi     # 0x188e9
movb $0x0, %al
callq 0x11190
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
callq 0xd540
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/decl.c
// Function: parameter
static struct decl *
parameter(struct scope *s)
{
	struct decl *d;
	char *name;
	struct qualtype t;
	enum storageclass sc;

	attr(NULL, 0);
	t = declspecs(s, &sc, NULL, NULL);
	if (!t.type)
		error(&tok.loc, "no type in parameter declaration");
	if (sc && sc != SCREGISTER)
		error(&tok.loc, "parameter declaration has invalid storage-class specifier");
	t = declarator(s, t, &name, NULL, true);
	t.type = typeadjust(t.type, &t.qual);
	d = mkdecl(name, DECLOBJECT, t.type, t.qual, LINKNONE);
	d->u.obj.storage = SDAUTO;
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x3360
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x34(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x3a30
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6ebb
leaq 0x1b2ff(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x120c1(%rip), %rsi     # 0x18f75
movb $0x0, %al
callq 0x11190
cmpl $0x0, -0x34(%rbp)
je 0x6ee0
cmpl $0x20, -0x34(%rbp)
je 0x6ee0
leaq 0x1b2da(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x120bd(%rip), %rsi     # 0x18f96
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rax
leaq -0x18(%rbp), %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x42f0
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x11ed0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x28(%rbp), %ecx
movl $0x1, %esi
xorl %r8d, %r8d
callq 0x38c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, 0x44(%rax)
movq -0x10(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl -0xc(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x6fb5
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ffe
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x6fc6
cmpl $0x2, -0x8(%rbp)
jne 0x6feb
cmpq $0x0, -0x18(%rbp)
je 0x6fd9
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x6fe3
movl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x6fe3
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ffe
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/eval.c
// Function: unary
static void
unary(struct expr *expr, enum tokenkind op, struct expr *l)
{
	expr->kind = EXPRCONST;
	if (l->type->prop & PROPFLOAT)
		op |= F;
	switch (op) {
	case TSUB:      expr->u.constant.u = -l->u.constant.u; break;
	case TSUB|F:    expr->u.constant.f = -l->u.constant.f; break;
	default:
		fatal("internal error; unknown unary expression");
	}
	cast(expr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x75cb
movl -0xc(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x4d, %eax
je 0x75e4
jmp 0x75d8
movl -0x1c(%rbp), %eax
subl $0x14d, %eax            # imm = 0x14D
je 0x75f8
jmp 0x7623
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x7631
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
jmp 0x7631
leaq 0x11c4e(%rip), %rdi     # 0x19278
movb $0x0, %al
callq 0x12650
movq -0x8(%rbp), %rdi
callq 0x7640
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x768c
cmpl $0x4, -0xc(%rbp)
jne 0x768a
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x30(%rax)
jmp 0x770b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7709
movl -0xc(%rbp), %eax
shll $0x3, %eax
movl %eax, %eax
movl $0x40, %ecx
subq %rax, %rcx
movq $-0x1, %rax
shrq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
andq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x40(%rax)
je 0x7707
movl -0xc(%rbp), %eax
shll $0x3, %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
xorq -0x18(%rbp), %rcx
subq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x7709
jmp 0x770b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/expr.c
// Function: delexpr
void
delexpr(struct expr *e)
{
	struct expr *sub;

	switch (e->kind) {
	case EXPRCALL:
		delexpr(e->base);
		while (sub = e->u.call.args) {
			e->u.call.args = sub->next;
			delexpr(sub);
		}
		break;
	case EXPRBITFIELD:
	case EXPRINCDEC:
	case EXPRUNARY:
	case EXPRCAST:
		delexpr(e->base);
		break;
	case EXPRBINARY:
		delexpr(e->u.binary.l);
		delexpr(e->u.binary.r);
		break;
	case EXPRCOND:
		delexpr(e->base);
		delexpr(e->u.cond.t);
		delexpr(e->u.cond.f);
		break;
	/*
	XXX: compound assignment causes some reuse of expressions,
	so we can't free them without risk of a double-free

	case EXPRASSIGN:
		delexpr(e->assign.l);
		delexpr(e->assign.r);
		break;
	*/
	case EXPRCOMMA:
		while (sub = e->base) {
			e->base = sub->next;
			delexpr(sub);
		}
		break;
	}
	free(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x7fdc
movq -0x18(%rbp), %rax
leaq 0x113bd(%rip), %rcx     # 0x192cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7ee0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7f52
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x7ee0
jmp 0x7f25
jmp 0x7fdc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7ee0
jmp 0x7fdc
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x7ee0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7ee0
jmp 0x7fdc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7ee0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x7ee0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7ee0
jmp 0x7fdc
jmp 0x7fad
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7fda
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x7ee0
jmp 0x7fad
jmp 0x7fdc
movq -0x8(%rbp), %rdi
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x8227
movb $0x0, -0x1(%rbp)
jmp 0x8286
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x11, (%rax)
jne 0x823a
movb $0x1, -0x1(%rbp)
jmp 0x8286
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x8275
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xc, (%rax)
jne 0x826f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x197cf(%rip), %rcx     # 0x21a38
cmpq %rcx, 0x20(%rax)
je 0x8275
movb $0x0, -0x1(%rbp)
jmp 0x8286
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/expr.c
// Function: encodechar8
static size_t
encodechar8(void *dst, uint_least32_t chr, bool hexoct)
{
	if (!hexoct)
		return utf8enc(dst, chr);
	*(unsigned char *)dst = chr;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x879e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12160
movq %rax, -0x8(%rbp)
jmp 0x87b1
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/expr.c
// Function: encodechar16
static size_t
encodechar16(void *dst, uint_least32_t chr, bool hexoct)
{
	if (!hexoct)
		return utf16enc(dst, chr) * sizeof(uint_least16_t);
	*(uint_least16_t *)dst = chr;
	return sizeof(uint_least16_t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x87f1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12440
shlq %rax
movq %rax, -0x8(%rbp)
jmp 0x8806
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e57
movq -0x8(%rbp), %rdi
callq 0x9da0
movq %rax, -0x10(%rbp)
jmp 0x8e59
leaq 0x19348(%rip), %rax     # 0x221a8
movl (%rax), %edi
callq 0x9fe0
movl %eax, -0x40(%rbp)
cmpl -0x14(%rbp), %eax
jl 0x8ef9
leaq 0x1932e(%rip), %rax     # 0x221a8
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
leaq 0x19322(%rip), %rax     # 0x221a8
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0xd540
movq -0x8(%rbp), %rdi
callq 0x9da0
movq %rax, -0x20(%rbp)
leaq 0x192f1(%rip), %rax     # 0x221a8
movl (%rax), %edi
callq 0x9fe0
movl %eax, -0x44(%rbp)
cmpl -0x40(%rbp), %eax
jle 0x8edc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0x8e30
movq %rax, -0x20(%rbp)
jmp 0x8eb0
movl -0x3c(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x95f0
movq %rax, -0x10(%rbp)
jmp 0x8e59
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
leaq 0x19259(%rip), %rax     # 0x221a8
cmpl $0x6e, (%rax)
je 0x8f56
jmp 0x8f5d
callq 0xd540
jmp 0x8f24
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8f72
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f8c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0xc, %edi
callq 0x9040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8340
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8340
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
movl %eax, %ecx
callq 0x11cb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8290
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8290
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x40, %edi
callq 0x127c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x5(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8b40
movq %rax, %rdi
callq 0x7010
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x9105
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x911e
leaq 0x1909c(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x109c2(%rip), %rsi     # 0x19ad9
movb $0x0, %al
callq 0x11190
testb $0x1, -0x9(%rbp)
jne 0x915d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x40(%rax)
je 0x915d
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
je 0x915d
leaq 0x1905d(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0x109a6(%rip), %rsi     # 0x19afc
movb $0x0, %al
callq 0x11190
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x9040
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x8290
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/expr.c
// Function: precedence
static int
precedence(enum tokenkind t)
{
	switch (t) {
	case TLOR:     return 0;
	case TLAND:    return 1;
	case TBOR:     return 2;
	case TXOR:     return 3;
	case TBAND:    return 4;
	case TEQL:
	case TNEQ:     return 5;
	case TLESS:
	case TGREATER:
	case TLEQ:
	case TGEQ:     return 6;
	case TSHL:
	case TSHR:     return 7;
	case TADD:
	case TSUB:     return 8;
	case TMUL:
	case TDIV:
	case TMOD:     return 9;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x4a, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0xa066
movq -0x10(%rbp), %rax
leaq 0xf509(%rip), %rcx      # 0x1950c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xa06d
movl $0x1, -0x4(%rbp)
jmp 0xa06d
movl $0x2, -0x4(%rbp)
jmp 0xa06d
movl $0x3, -0x4(%rbp)
jmp 0xa06d
movl $0x4, -0x4(%rbp)
jmp 0xa06d
movl $0x5, -0x4(%rbp)
jmp 0xa06d
movl $0x6, -0x4(%rbp)
jmp 0xa06d
movl $0x7, -0x4(%rbp)
jmp 0xa06d
movl $0x8, -0x4(%rbp)
jmp 0xa06d
movl $0x9, -0x4(%rbp)
jmp 0xa06d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0xd, %eax
je 0xa69c
jmp 0xa692
movl -0x18(%rbp), %eax
subl $0xe, %eax
je 0xa6da
jmp 0xa6f4
movq -0x8(%rbp), %rsi
movl $0x4a, %edi
callq 0x9410
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
orl -0x14(%rbp), %esi
callq 0x11760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x5(%rax)
jmp 0xa6f4
movq -0x8(%rbp), %rsi
movl $0x4a, %edi
callq 0x9410
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x5(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0xb8a9
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x15e24(%rip), %rax     # 0x216b0
movq (%rax,%rcx,8), %rdx
leaq 0x16911(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xeaba(%rip), %rsi      # 0x1a35c
movb $0x0, %al
callq 0x11190
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xb8e1
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x15dec(%rip), %rax     # 0x216b0
movq (%rax,%rcx,8), %rdx
leaq 0x168d9(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xeaad(%rip), %rsi      # 0x1a387
movb $0x0, %al
callq 0x11190
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movl $0x5, %edi
callq 0x9040
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)