LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xb099
movl %eax, %ebx
testb %al, %al
je 0x53aa
leaq 0xdb4f(%rip), %rsi      # 0x12e44
movl $0x42, %edi
callq 0xb07a
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a9
movq %rax, %r15
movl $0x6e, %edi
callq 0xb099
testb %al, %al
je 0x536b
leaq 0x16de4(%rip), %r14     # 0x1c108
leaq 0xdb2d(%rip), %rdx      # 0x12e58
movq %r14, %rdi
movl $0x7, %esi
callq 0xd3c3
movq %rsp, %rdi
movl $0x1, %esi
callq 0x6b77
testq %r15, %r15
jne 0x5389
movl (%rsp), %edx
decl %edx
movq 0x8(%rsp), %rcx
addq $0x8, %r14
leaq 0xdb1b(%rip), %rsi      # 0x12e7a
movq %r14, %rdi
xorl %eax, %eax
callq 0xd56a
jmp 0x5389
testq %r15, %r15
jne 0x5389
leaq 0x16d91(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xdb16(%rip), %rsi      # 0x12e98
xorl %eax, %eax
callq 0xd56a
leaq 0xdb20(%rip), %r14      # 0x12eb0
movl $0x43, %edi
movq %r14, %rsi
callq 0xb07a
movl $0x61, %edi
movq %r14, %rsi
callq 0xb07a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5740
movq (%rbx), %rdx
leaq 0x169da(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xd836(%rip), %rsi      # 0x12f6f
xorl %eax, %eax
callq 0xd56a
movq 0x10(%rbx), %rax
movl 0x8(%rax), %eax
cmpl %eax, 0x40(%rbx)
jge 0x574f
movl %eax, 0x40(%rbx)
cmpl $0x2, 0x44(%rbx)
jne 0x5769
movzbl %bpl, %ecx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x103ee
jmp 0x5774
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10fd7
movb $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x167ef(%rip)     # 0x1bf88
jne 0x57ac
leaq 0x167e6(%rip), %rdi     # 0x1bf88
movl $0x40, %esi
callq 0xa6f3
cmpl $0x2, (%rbx)
jne 0x587a
movq 0x30(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa6c4
leaq 0x167b9(%rip), %rdi     # 0x1bf88
movq %r14, %rsi
callq 0xa7db
movq (%rax), %r15
testq %r15, %r15
jne 0x586b
movq %rax, %r14
movq 0x8(%rbx), %r12
movl $0x48, %edi
callq 0xe13e
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
leaq 0xcd23(%rip), %rax      # 0x1253b
movq %rax, (%r15)
movq $0x1, 0x8(%r15)
movq %r12, 0x10(%r15)
movl $0x0, 0x18(%r15)
testq %r12, %r12
je 0x583d
movl 0x8(%r12), %eax
movl %eax, 0x40(%r15)
movq %r15, %rdi
callq 0xe328
movq %rax, 0x20(%r15)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rsi
xorl %edi, %edi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x9ae0
movq %r15, %rdi
movq %rax, %rsi
callq 0x10fd7
movq %r15, (%r14)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x101f2(%rip), %rdi     # 0x15a73
leaq 0xcc43(%rip), %rsi      # 0x124cb
leaq 0xcc85(%rip), %rcx      # 0x12514
movl $0x46c, %edx            # imm = 0x46C
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O1/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 0x16707(%rip), %rbx     # 0x1bfa8
testq %rbx, %rbx
je 0x58c0
cmpb $0x0, 0x30(%rbx)
jne 0x58ba
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5708
movq 0x38(%rbx), %rbx
jmp 0x58a1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1683e(%rip), %rax     # 0x1c108
movl (%rax), %ecx
xorl %ebx, %ebx
cmpl $0x32, %ecx
jg 0x58e4
cmpl $0xf, %ecx
je 0x58f5
cmpl $0x22, %ecx
jne 0x591f
movl $0x4, %eax
jmp 0x58fa
cmpl $0x35, %ecx
je 0x5908
cmpl $0x33, %ecx
jne 0x591f
movl $0x8, %eax
jmp 0x58fa
movl $0x2, %eax
orl %eax, (%rdi)
callq 0xa9d0
movl $0x1, %ebx
jmp 0x591f
addq $0x8, %rax
leaq 0xcdc0(%rip), %rsi      # 0x126d3
xorl %ebx, %ebx
movq %rax, %rdi
xorl %eax, %eax
callq 0xd56a
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x65eb
testb $0x2, %cl
je 0x65ea
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 0x65ea
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 0x65ea
cvtsd2ss 0x30(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ae5
movq 0x8(%rdi), %rcx
movl (%rcx), %edx
movb $0x1, %al
cmpl $0x11, %edx
je 0x6ae7
testb $0x2, 0x4(%rcx)
jne 0x6ae8
cmpl $0xc, %edx
jne 0x6ae5
movq 0x20(%rcx), %rax
cmpq 0x144bd(%rip), %rax     # 0x1afa0
je 0x6ae8
xorl %eax, %eax
retq
cmpq $0x0, 0x30(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x730b
movq %r14, %rdi
callq 0x7f4f
movq %rax, %r15
leaq 0x14df6(%rip), %rbx     # 0x1c108
movl (%rbx), %ebp
movl %ebp, %edi
callq 0x8172
cmpl %r12d, %eax
jl 0x7390
movl %eax, %r13d
movl %r12d, 0xc(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x20(%rsp)
movups 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
callq 0xa9d0
movq %r14, %rdi
callq 0x7f4f
movq %rax, %r12
movl (%rbx), %edi
callq 0x8172
cmpl %r13d, %eax
jle 0x7365
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x72e4
jmp 0x7347
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x78e0
movq %rax, %r15
movl (%rbx), %ebp
movl %ebp, %edi
callq 0x8172
movl %eax, %r13d
movl 0xc(%rsp), %r12d
cmpl %r12d, %eax
jge 0x7328
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_O1/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 0x7520
movq %rax, %rbx
leaq 0x14d4c(%rip), %r15     # 0x1c108
cmpl $0x6e, (%r15)
jne 0x73e0
movq %rbx, %r12
callq 0xa9d0
movq %r14, %rdi
callq 0x7520
movq %rax, 0x20(%r12)
cmpl $0x6e, (%r15)
movq %rax, %r12
je 0x73c5
cmpq $0x0, 0x20(%rbx)
je 0x741a
movq 0x8(%rax), %r14
movl $0x40, %edi
callq 0xe13e
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_O1/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 0x745c
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 0x747c
movl 0x10(%rdx), %ecx
shll $0x3, %ecx
movswl 0x30(%rax), %r8d
movswl 0x32(%rax), %eax
addl %r8d, %eax
subl %eax, %ecx
callq 0xdac0
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6af1
movq %rax, (%r14)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6af1
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x70c0
movq %rax, %rdi
callq 0x61cc
movq %rax, %rbx
cmpl $0x1, (%rax)
jne 0x74cd
movq 0x8(%rbx), %rax
testb $0x2, 0x4(%rax)
jne 0x74e6
leaq 0x14c34(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc16a(%rip), %rsi      # 0x13649
xorl %eax, %eax
callq 0xd56a
testb %bpl, %bpl
jne 0x7515
movq 0x8(%rbx), %rax
cmpb $0x1, 0x40(%rax)
jne 0x7515
cmpq $0x0, 0x30(%rbx)
jns 0x7515
leaq 0x14c05(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc15e(%rip), %rsi      # 0x1366c
xorl %eax, %eax
callq 0xd56a
movq 0x30(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/expr.c
// Function: mkassignexpr
static struct expr *
mkassignexpr(struct expr *l, struct expr *r)
{
	struct expr *e;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movl $0x40, %edi
callq 0xe13e
movq %rax, %r15
movl $0x0, 0x10(%rax)
movq %r12, 0x8(%rax)
movw $0x0, 0x4(%rax)
movl $0xb, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movq $0x0, 0x28(%rax)
movq %r14, 0x30(%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6af1
movq %rax, 0x38(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7831
movl %edi, %esi
cmpl $0x4a, %edi
jne 0x7870
cmpb $0x1, 0x5(%rbx)
jne 0x779c
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x3250
movq %r14, %rbx
cmpb $0x0, 0x4(%rbx)
jne 0x77c9
movq 0x8(%rbx), %rax
movl (%rax), %eax
addl $-0xe, %eax
cmpl $0x3, %eax
jb 0x77c9
leaq 0x14951(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc8ba(%rip), %rsi      # 0x1407c
xorl %eax, %eax
callq 0xd56a
cmpl $0x4, (%rbx)
jne 0x77e7
leaq 0x14933(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc8d0(%rip), %rsi      # 0x140b0
xorl %eax, %eax
callq 0xd56a
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0xd80f
movq %rax, %r15
movl $0x40, %edi
callq 0xe13e
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 0x7881
movq 0x8(%rbx), %rax
cmpl $0xc, (%rax)
je 0x7853
leaq 0x148c7(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xc885(%rip), %rsi      # 0x140d1
xorl %eax, %eax
callq 0xd56a
cmpl $0x7, (%rbx)
jne 0x788a
cmpl $0x4a, 0x14(%rbx)
jne 0x788a
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movq 0x20(%rax), %rax
movq %rax, 0x8(%rdi)
jmp 0x78d6
leaq 0xc879(%rip), %rdi      # 0x140f0
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xe054
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rax
movq 0x20(%rax), %r14
movl $0x40, %edi
callq 0xe13e
movq %rax, %rdi
movl $0x0, 0x10(%rax)
movq %r14, 0x8(%rax)
movw $0x0, 0x4(%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 0x9444
// File: /workspace/github_c_makefile_star2_O1/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 0x9484
cmpl $0xd, %eax
jne 0x9498
movl 0x10(%rbx), %ebp
movl $0x4a, %edi
movq %rbx, %rsi
callq 0x776b
movq %rax, %rbx
movq 0x20(%r14), %rdi
orl 0x38(%r14), %ebp
movl %ebp, %esi
callq 0xd80f
movq %rax, 0x8(%rbx)
jmp 0x9494
movl $0x4a, %edi
movq %rbx, %rsi
callq 0x776b
movq %rax, %rbx
movb $0x1, 0x5(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x994f
leaq 0x11cde(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x127cb(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa584(%rip), %rsi      # 0x13ecc
xorl %eax, %eax
callq 0xd56a
testb $0x2, 0x10(%r14)
je 0x997a
leaq 0x11cb3(%rip), %rax     # 0x1b610
movq (%rax,%r15,8), %rdx
leaq 0x127a0(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa584(%rip), %rsi      # 0x13ef7
xorl %eax, %eax
callq 0xd56a
movq 0x8(%r14), %r15
movl $0x40, %edi
callq 0xe13e
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_O1/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 0x99f7
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 0x99df
leaq 0x10bb2(%rip), %r12     # 0x1a5b0
xorl %r15d, %r15d
movq -0x8(%r12), %rsi
movq %r14, %rdi
callq 0x3140
testl %eax, %eax
je 0x9a3a
movq (%r12), %rsi
testq %rsi, %rsi
je 0x9a27
movq %r14, %rdi
callq 0x3140
testl %eax, %eax
je 0x9a3a
incq %r15
addq $0x18, %r12
cmpq $0x6, %r15
jne 0x9a01
movl $0x6, %r15d
cmpq $0x6, %r15
jne 0x9a5c
leaq 0x126c1(%rip), %rdi     # 0x1c108
addq $0x8, %rdi
leaq 0xa049(%rip), %rsi      # 0x13a9b
movq %r14, %rdx
xorl %eax, %eax
callq 0xd56a
cmpq $0x5, %r15
ja 0x9aac
orb %r15b, %bpl
movzbl %bpl, %r12d
andl $0x1, %r12d
incq %r12
leaq (%r15,%r15,2), %rax
leaq 0x10b25(%rip), %rcx     # 0x1a5a0
leaq (%rcx,%rax,8), %r13
leal (,%r12,8), %eax
leaq (%rax,%rax,2), %rbp
movq (%r13), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xdd37
testb %al, %al
jne 0x9acc
addq %r12, %r15
addq %rbp, %r13
cmpq $0x5, %r15
jbe 0x9a8b
leaq 0x12655(%rip), %rdi     # 0x1c108
movq 0x20(%rdi), %rdx
addq $0x8, %rdi
leaq 0x9ffe(%rip), %rsi      # 0x13ac0
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xd56a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe13e
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
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/init.c
// Function: focus
static void
focus(struct initparser *p)
{
	struct type *t;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x408(%rdi), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
leal -0xf(%rdx), %esi
cmpl $0x2, %esi
jae 0xa2c8
movq 0x48(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x408(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r14
movq 0x408(%rbx), %rax
movq (%rax), %r15
addq $0x20, %rax
movq %rax, 0x408(%rbx)
leaq 0x400(%rbx), %rcx
cmpq %rcx, %rax
jne 0xa2b0
leaq 0xa316(%rip), %rdi      # 0x145bf
xorl %eax, %eax
callq 0xe054
movq 0x408(%rbx), %rax
movq %r14, 0x8(%rax)
movq %r15, (%rax)
movb $0x0, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpl $0xd, %edx
jne 0xa2f4
movq 0x20(%rcx), %r14
movq $0x0, 0x10(%rax)
movq 0x408(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x1, 0x3c(%rax)
jne 0xa281
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
jmp 0xa281
leaq 0xa308(%rip), %rdi      # 0x14603
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xe054
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/init.c
// Function: findmember
static bool
findmember(struct initparser *p, char *name)
{
	struct member *m;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x408(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rbp
testq %rbp, %rbp
setne %bl
je 0xa425
movq %rsi, %r15
movq %rdi, %r14
leaq 0x400(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0xa35e
movq %r15, %rsi
callq 0x3140
testl %eax, %eax
jne 0xa3c1
jmp 0xa3d3
movq 0x8(%rbp), %r12
movq 0x18(%rbp), %r15
movq 0x408(%r14), %rax
movq (%rax), %r13
addq $0x20, %rax
movq %rax, 0x408(%r14)
cmpq 0x8(%rsp), %rax
jne 0xa390
leaq 0xa236(%rip), %rdi      # 0x145bf
xorl %eax, %eax
callq 0xe054
addq %r15, %r13
movq 0x408(%r14), %rax
movq %r12, 0x8(%rax)
movq %r13, (%rax)
movb $0x0, 0x18(%rax)
movq %r14, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0xa307
testb %al, %al
jne 0xa425
addq $-0x20, 0x408(%r14)
movq 0x28(%rbp), %rbp
testq %rbp, %rbp
setne %bl
jne 0xa347
jmp 0xa425
movq 0x408(%r14), %rax
movq %rbp, 0x10(%rax)
movq 0x8(%rbp), %r15
movq 0x18(%rbp), %rbp
movq 0x408(%r14), %rax
movq (%rax), %r12
addq $0x20, %rax
movq %rax, 0x408(%r14)
cmpq 0x8(%rsp), %rax
jne 0xa410
leaq 0xa1b6(%rip), %rdi      # 0x145bf
xorl %eax, %eax
callq 0xe054
addq %rbp, %r12
movq 0x408(%r14), %rax
movq %r15, 0x8(%rax)
movq %r12, (%rax)
movb $0x0, 0x18(%rax)
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/map.c
// Function: mapinit
void
mapinit(struct map *h, size_t cap)
{
	size_t i;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0xa759
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0x18, %edx
xorl %edi, %edi
callq 0xe10a
movq %rax, 0x10(%r14)
movl $0x8, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0xe10a
movq %rax, 0x18(%r14)
testq %rbx, %rbx
je 0xa751
movq 0x10(%r14), %rax
addq $0x8, %rax
movq $0x0, (%rax)
addq $0x18, %rax
decq %rbx
jne 0xa741
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9f56(%rip), %rdi      # 0x146b6
leaq 0x9f60(%rip), %rsi      # 0x146c7
leaq 0x9f5f(%rip), %rcx      # 0x146cd
movl $0x21, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/map.c
// Function: mapfree
void
mapfree(struct map *h, void del(void *))
{
	size_t i;

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

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

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

	return &h->vals[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rbp
movq %rbp, %rax
shrq %rax
cmpq (%rdi), %rax
jae 0xa8bd
movq 0x10(%rbx), %rax
movq %rax, (%rsp)
movq 0x18(%rbx), %r15
leaq (,%rbp,2), %rsi
movq %rsi, 0x8(%rbx)
movl $0x18, %edx
xorl %edi, %edi
callq 0xe10a
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rsi
movl $0x8, %edx
xorl %edi, %edi
callq 0xe10a
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xa85c
movq 0x10(%rbx), %rcx
addq $0x8, %rcx
movq $0x0, (%rcx)
addq $0x18, %rcx
decq %rax
jne 0xa84c
testq %rbp, %rbp
je 0xa8ac
xorl %r12d, %r12d
movq (%rsp), %r13
cmpq $0x0, 0x8(%r13)
je 0xa8a0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa911
movq 0x10(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movups (%r13), %xmm0
movups %xmm0, (%rcx,%rdx,8)
movq 0x10(%r13), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movq (%r15,%r12,8), %rcx
movq 0x18(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %r12
addq $0x18, %r13
cmpq %r12, %rbp
jne 0xa868
movq (%rsp), %rdi
callq 0x3250
movq %r15, %rdi
callq 0x3250
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa911
movq 0x10(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
cmpq $0x0, 0x8(%rcx,%rdx,8)
jne 0xa8fa
leaq (%rcx,%rdx,8), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rcx)
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq (%rbx)
shlq $0x3, %rax
addq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/map.c
// Function: keyindex
static size_t
keyindex(struct map *h, struct mapkey *k)
{
	size_t i;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x11726(%rip), %rbx     # 0x1c108
callq 0xb0bc
movq %rax, %r14
testq %rax, %rax
jne 0xa9fa
movq %rbx, %rdi
callq 0xb25f
movq %rbx, %r14
movq %r14, %rdi
callq 0xaab8
testb %al, %al
jne 0xa9e2
cmpl $0x2, (%r14)
jne 0xaa17
movl 0x115d6(%rip), %eax     # 0x1bfe8
andl $0x1, %eax
je 0xa9e2
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
leaq 0x116e1(%rip), %rcx     # 0x1c108
movups %xmm0, (%rcx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
cmpl $0x4, (%rcx)
jne 0xaaa9
leaq 0x116c6(%rip), %rax     # 0x1c108
movq 0x20(%rax), %rbx
movl $0x46, %r15d
xorl %r13d, %r13d
leaq 0xfbda(%rip), %r14      # 0x1a630
leaq (%r15,%r13), %r12
shrq %r12
movq %r12, %rbp
shlq $0x4, %rbp
movq (%rbp,%r14), %rsi
movq %rbx, %rdi
callq 0x3140
testl %eax, %eax
je 0xaa89
js 0xaa7f
incq %r12
movq %r12, %r13
jmp 0xaa82
movq %r12, %r15
cmpq %r15, %r13
jb 0xaa56
jmp 0xaaa9
addq %rbp, %r14
movq %rbx, %rdi
callq 0x3250
movl 0x8(%r14), %eax
leaq 0x11669(%rip), %rcx     # 0x1c108
movl %eax, (%rcx)
movq $0x0, 0x20(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/pp.c
// Function: peek
bool
peek(int kind)
{
	static struct token pending;
	struct token old;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x11142(%rip), %r14     # 0x1c108
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0xa9d0
movl (%r14), %ebp
cmpl %ebx, %ebp
jne 0xaff4
callq 0xa9d0
jmp 0xb06a
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x10fec(%rip)    # 0x1bff0
movq 0x20(%r14), %rax
movq %rax, 0x11001(%rip)     # 0x1c010
movups %xmm1, 0x10fea(%rip)    # 0x1c000
leaq 0x10fd3(%rip), %r15     # 0x1bff0
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%r14)
movb 0x10fb6(%rip), %r14b    # 0x1bff5
leaq 0x10fd2(%rip), %rdi     # 0x1c018
movl $0x18, %esi
callq 0xe18c
movq %r15, (%rax)
movq $0x1, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb %r14b, 0x10f8b(%rip)    # 0x1bff5
cmpl %ebx, %ebp
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/pp.c
// Function: ctxnext
static struct token *
ctxnext(void)
{
	struct frame *f;
	struct token *t;
	struct macro *m;
	bool space;
	size_t i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10f4a(%rip), %r15     # 0x1c018
xorl %ebx, %ebx
movl $0x18, %esi
movq %r15, %rdi
callq 0xe23a
movq %rax, %r14
cmpq $0x0, 0x10f38(%rip)     # 0x1c020
sete %al
je 0xb22e
cmpq $0x0, 0x8(%r14)
jne 0xb150
movq 0x10(%r14), %r12
testq %r12, %r12
je 0xb134
movb $0x0, 0x10(%r12)
cmpl $0x1, (%r12)
jne 0xb12d
cmpq $0x0, 0x20(%r12)
je 0xb12d
movq 0x28(%r12), %rax
movq (%rax), %rdi
callq 0x3250
movq 0x28(%r12), %rdi
callq 0x3250
decq 0x10efc(%rip)           # 0x1c030
addq $-0x18, 0x10ee4(%rip)   # 0x1c020
sete %al
je 0xb22e
cmpq $0x0, -0x10(%r14)
leaq -0x18(%r14), %r14
je 0xb0f8
testb %al, %al
jne 0xb22e
movq 0x10(%r14), %r12
testq %r12, %r12
je 0xb220
cmpl $0x1, (%r12)
jne 0xb220
movq (%r14), %r13
movb 0x5(%r13), %bpl
movl (%r13), %eax
cmpl $0x4, %eax
jne 0xb1bf
movq %r12, %rdi
movq %r13, %rsi
callq 0xba7f
cmpq $-0x1, %rax
je 0xb220
decq 0x8(%r14)
addq $0x28, %r13
movq %r13, (%r14)
movq 0x28(%r12), %rcx
imulq $0x38, %rax, %rax
movq 0x8(%rcx,%rax), %r12
testq %r12, %r12
je 0xb0d0
addq %rax, %rcx
movq (%rcx), %rbx
jmp 0xb1f9
cmpl $0x6f, %eax
jne 0xb220
addq $-0x2, 0x8(%r14)
leaq 0x28(%r13), %rsi
addq $0x50, %r13
movq %r13, (%r14)
movq %r12, %rdi
callq 0xba7f
cmpq $-0x1, %rax
je 0xb240
movq 0x28(%r12), %rcx
imulq $0x38, %rax, %rax
leaq (%rcx,%rax), %rbx
addq $0x10, %rbx
movl $0x1, %r12d
leaq 0x10e18(%rip), %rdi     # 0x1c018
movl $0x18, %esi
callq 0xe18c
movq %rax, %r14
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb %bpl, 0x5(%rbx)
decq 0x8(%r14)
movq (%r14), %rbx
leaq 0x28(%rbx), %rax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x94ca(%rip), %rdi      # 0x14711
leaq 0x94a2(%rip), %rsi      # 0x146f0
leaq 0x94a0(%rip), %rcx      # 0x146f5
movl $0xb8, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/pp.c
// Function: macroparam
static size_t
macroparam(struct macro *m, struct token *t)
{
	size_t i;

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

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

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

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

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

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

// Assembly:
movq 0x104ab(%rip), %rax     # 0x1c050
cmpq $0x0, 0x8(%rax)
je 0xbbad
retq
pushq %rax
movq 0x10(%rax), %rdi
leaq 0x8f9e(%rip), %rsi      # 0x14b57
callq 0x31e0
movq 0x1048b(%rip), %rcx     # 0x1c050
movq %rax, 0x8(%rcx)
testq %rax, %rax
jne 0xbbe0
movq 0x10(%rcx), %rsi
leaq 0x8a64(%rip), %rdi      # 0x1463d
xorl %eax, %eax
callq 0xe054
movq 0x10469(%rip), %rdi     # 0x1c050
popq %rax
jmp 0xbb3a
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/scan.c
// Function: bufadd
static void
bufadd(struct buffer *b, int c)
{
	if (b->len >= b->cap) {
		b->cap = b->cap ? b->cap * 2 : 1<<8;
		b->str = xreallocarray(b->str, b->cap, 1);
	}
	b->str[b->len++] = c;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xbb3a
leaq 0x10(%rbx), %r14
leaq 0x8adf(%rip), %r15      # 0x14d72
leaq 0x8abe(%rip), %r12      # 0x14d58
movl (%rbx), %eax
cmpl $0x21, %eax
jg 0xc2cf
cmpl $-0x1, %eax
je 0xc2b8
cmpl $0xa, %eax
jne 0xc2c5
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xd56a
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xd56a
movq %rbx, %rdi
callq 0xbb3a
jmp 0xc29a
cmpl $0x5c, %eax
jne 0xc2de
movq %rbx, %rdi
callq 0xc4db
jmp 0xc29a
cmpl $0x22, %eax
jne 0xc2c5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbb3a
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/scan.c
// Function: op3
static int
op3(struct scanner *s, int t1, int t2, int t3)
{
	int c;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xbb3a
leaq 0x10(%rbx), %r14
leaq 0x8a9a(%rip), %r15      # 0x14dee
leaq 0x8a75(%rip), %r12      # 0x14dd0
movl (%rbx), %eax
cmpl $0x26, %eax
jg 0xc390
cmpl $-0x1, %eax
je 0xc379
cmpl $0xa, %eax
jne 0xc386
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xd56a
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xd56a
movq %rbx, %rdi
callq 0xbb3a
jmp 0xc35b
cmpl $0x5c, %eax
jne 0xc39f
movq %rbx, %rdi
callq 0xc4db
jmp 0xc35b
cmpl $0x27, %eax
jne 0xc386
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbb3a
// File: /workspace/github_c_makefile_star2_O1/michaelforney[P]cproc/scan.c
// Function: op4
static int
op4(struct scanner *s, int t1, int t2, int t3, int t4)
{
	int c;

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

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

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

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

	return TIDENT;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbb3a
movl (%rbx), %esi
cmpl $0x78, %esi
jne 0xc53a
movq %rbx, %rdi
callq 0xbb3a
callq 0x3240
movq %rax, %r14
movq (%rax), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xc51d
leaq 0x10(%rbx), %rdi
leaq 0x8872(%rip), %rsi      # 0x14d88
xorl %eax, %eax
callq 0xd56a
movq %rbx, %rdi
callq 0xbb3a
movq (%r14), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xc51d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %esi, %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc56a
movq %rbx, %rdi
callq 0xbb3a
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc532
movq %rbx, %rdi
callq 0xbb3a
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xc532
jmp 0xc580
leaq 0x883b(%rip), %rdi      # 0x14dac
movl $0xc, %edx
callq 0x3120
testq %rax, %rax
je 0xc58f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbb3a
addq $0x10, %rbx
leaq 0x881e(%rip), %rsi      # 0x14db8
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd56a
nop