LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/expr.c
// Function: designator
static void
designator(struct scope *s, struct type *t, unsigned long long *offset)
{
	char *name;
	struct member *m;
	unsigned long long i;

	for (;;) {
		switch (tok.kind) {
		case TLBRACK:
			if (t->kind != TYPEARRAY)
				error(&tok.loc, "index designator is only valid for array types");
			next();
			i = intconstexpr(s, false);
			expect(TRBRACK, "for index designator");
			t = t->base;
			*offset += i * t->size;
			break;
		case TPERIOD:
			if (t->kind != TYPESTRUCT && t->kind != TYPEUNION)
				error(&tok.loc, "member designator only valid for struct/union types");
			next();
			name = expect(TIDENT, "for member designator");
			m = typemember(t, name, offset);
			if (!m)
				error(&tok.loc, "%s has no member named '%s'", t->kind == TYPEUNION ? "union" : "struct", name);
			free(name);
			t = m->type;
			break;
		default:
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1647d(%rip), %rax     # 0x221a8
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x40, %eax
je 0xbd44
jmp 0xbd37
movl -0x34(%rbp), %eax
subl $0x46, %eax
je 0xbdb3
jmp 0xbe63
movq -0x10(%rbp), %rax
cmpl $0xd, (%rax)
je 0xbd66
leaq 0x16454(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xe54c(%rip), %rsi      # 0x1a2ab
movb $0x0, %al
callq 0x11190
callq 0xd540
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x90c0
movq %rax, -0x30(%rbp)
movl $0x41, %edi
leaq 0xe554(%rip), %rsi      # 0x1a2da
callq 0xd8d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xbe69
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
je 0xbdde
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
je 0xbdde
leaq 0x163dc(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xe518(%rip), %rsi      # 0x1a2ef
movb $0x0, %al
callq 0x11190
callq 0xd540
movl $0x4, %edi
leaq 0xe534(%rip), %rsi      # 0x1a323
callq 0xd8d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11f70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xbe4c
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0xe534(%rip), %rdx      # 0x1a355
leaq 0xdf8b(%rip), %rax      # 0x19db3
cmpl $0x10, %ecx
cmoveq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x1636e(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xe4f4(%rip), %rsi      # 0x1a339
movb $0x0, %al
callq 0x11190
movq -0x20(%rbp), %rdi
callq 0x3260
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xbe69
addq $0x40, %rsp
popq %rbp
retq
jmp 0xbd24
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x28, %edi
callq 0x127c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/init.c
// Function: advance
static void
advance(struct initparser *p)
{
	struct type *t;

	for (;;) {
		--p->sub;
		t = p->sub->type;
		switch (t->kind) {
		case TYPEARRAY:
			p->sub->u.idx += t->base->size;
			if (p->sub->u.idx == t->size) {
				if (!t->incomplete)
					break;
				t->size += t->base->size;
			}
			subobj(p, t->base, p->sub->u.idx);
			return;
		case TYPESTRUCT:
			p->sub->u.mem = p->sub->u.mem->next;
			if (p->sub->u.mem) {
				subobj(p, p->sub->u.mem->type, p->sub->u.mem->offset);
				return;
			}
			break;
		}
		if (p->sub == p->cur)
			error(&tok.loc, "too many initializers for type");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x408(%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xd, %eax
je 0xc676
jmp 0xc665
movl -0x14(%rbp), %eax
subl $0xf, %eax
je 0xc6fa
jmp 0xc761
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xc6d5
movq -0x10(%rbp), %rax
testb $0x1, 0x3c(%rax)
jne 0xc6bd
jmp 0xc761
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rdx
callq 0xca20
jmp 0xc797
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xc75f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdx
callq 0xca20
jmp 0xc797
jmp 0xc761
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x400(%rcx), %rax
jne 0xc792
leaq 0x15a28(%rip), %rdi     # 0x221a8
addq $0x8, %rdi
leaq 0xe297(%rip), %rsi      # 0x1aa22
movb $0x0, %al
callq 0x11190
jmp 0xc62c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xd, %eax
je 0xc7d7
jmp 0xc7c7
movl -0x14(%rbp), %eax
addl $-0xf, %eax
subl $0x2, %eax
jb 0xc833
jmp 0xc86e
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x3c(%rax)
je 0xc831
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xc87e
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc87e
leaq 0xe1cc(%rip), %rdi      # 0x1aa41
movb $0x0, %al
callq 0x12650
jmp 0xc88f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xca20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/init.c
// Function: initadd
static void
initadd(struct initparser *p, struct init *new)
{
	struct init **init, *old;

	init = p->last;
	for (; old = *init; init = &old->next) {
		if (old->end * 8 - old->bits.after <= new->start * 8 + new->bits.before)
			continue;
		/* no overlap, insert before `old` */
		if (new->end * 8 - new->bits.after <= old->start * 8 + old->bits.before)
			break;
		/* replace any initializers that `new` covers */
		if (old->end * 8 - old->bits.after <= new->end * 8 - new->bits.after) {
			do old = old->next;
			while (old && old->end * 8 - old->bits.after <= new->end * 8 - new->bits.after);
			break;
		}
		/* `old` covers `new`, keep looking */
	}
	new->next = old;
	*init = new;
	p->last = &new->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x418(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xc9e6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
movq -0x20(%rbp), %rcx
movswq 0x1a(%rcx), %rcx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
movq -0x10(%rbp), %rdx
movswq 0x18(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0xc909
jmp 0xc9d5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
movq -0x10(%rbp), %rcx
movswq 0x1a(%rcx), %rcx
subq %rcx, %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
movq -0x20(%rbp), %rdx
movswq 0x18(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0xc942
jmp 0xc9e6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
movq -0x20(%rbp), %rcx
movswq 0x1a(%rcx), %rcx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
movq -0x10(%rbp), %rdx
movswq 0x1a(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0xc9d3
jmp 0xc979
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0xc9ca
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
movq -0x20(%rbp), %rcx
movswq 0x1a(%rcx), %rcx
subq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
movq -0x10(%rbp), %rdx
movswq 0x1a(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
setbe %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xc979
jmp 0xc9e6
jmp 0xc9d5
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0xc8bb
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x418(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/init.c
// Function: subobj
static void
subobj(struct initparser *p, struct type *t, unsigned long long off)
{
	off += p->sub->offset;
	if (++p->sub == p->obj + LEN(p->obj))
		fatal("internal error: too many designators");
	p->sub->type = t;
	p->sub->offset = off;
	p->sub->iscur = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq 0x408(%rcx), %rax
addq $0x20, %rax
movq %rax, 0x408(%rcx)
movq -0x8(%rbp), %rcx
addq $0x400, %rcx            # imm = 0x400
cmpq %rcx, %rax
jne 0xca7e
leaq 0xdf86(%rip), %rdi      # 0x1a9fd
movb $0x0, %al
callq 0x12650
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x408(%rax), %rax
movb $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcba0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xcb45
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0xcb43
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xca20
movb $0x1, -0x1(%rbp)
jmp 0xcba4
jmp 0xcb8d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xca20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcac0
testb $0x1, %al
jne 0xcb71
jmp 0xcb77
movb $0x1, -0x1(%rbp)
jmp 0xcba4
movq -0x10(%rbp), %rax
movq 0x408(%rax), %rcx
addq $-0x20, %rcx
movq %rcx, 0x408(%rax)
jmp 0xcb8f
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcae7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/map.c
// Function: hash
static unsigned long
hash(const void *ptr, size_t len)
{
	unsigned long h;
	const unsigned char *pos, *end;

	/* FNV-1a */
	h = 0x811c9dc5;
	for (pos = ptr, end = pos + len; pos != end; ++pos)
		h = (h ^ *pos) * 0x1000193;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xd01a
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
xorq %rcx, %rax
imulq $0x1000193, %rax, %rax  # imm = 0x1000193
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcfe9
movq -0x18(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0xd047
jmp 0xd066
leaq 0xdaa6(%rip), %rdi      # 0x1aaf4
leaq 0xdab0(%rip), %rsi      # 0x1ab05
movl $0x21, %edx
leaq 0xdaaa(%rip), %rcx      # 0x1ab0b
callq 0x30f0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x18, %edx
callq 0x12760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
movl $0x8, %edx
callq 0x12760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd0ef
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd0bf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd16c
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd16a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xd15a
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
jmp 0xd15c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd11f
jmp 0xd16c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
je 0xd414
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd4b0
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd41d
jmp 0xd43a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xd3da
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xd5d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd610
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xd58e
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
movb %al, -0xa(%rbp)
jne 0xd588
movl 0x14b0e(%rip), %eax     # 0x22088
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xd548
movq -0x8(%rbp), %rsi
leaq 0x14c08(%rip), %rdi     # 0x221a8
movl $0x28, %edx
callq 0x3190
leaq 0x14bf7(%rip), %rax     # 0x221a8
cmpl $0x4, (%rax)
jne 0xd5c2
leaq 0x14beb(%rip), %rdi     # 0x221a8
callq 0xd6e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: rawnext
static struct token *
rawnext(void)
{
	struct token *t;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xd950
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd5fc
leaq 0x14bb9(%rip), %rax     # 0x221a8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdb70
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: expand
static bool
expand(struct token *t)
{
	struct macro *m;
	bool space;

	if (t->kind != TIDENT)
		return false;
	m = macroget(t->lit);
	if (!m || m->hide)
		t->hide = true;
	if (t->hide)
		return false;
	space = t->space;
	if (m->kind == MACROFUNC) {
		if (!peekparen())
			return false;
		expandfunc(m);
	}
	ctxpush(m->token, m->ntoken, m, space);
	m->hide = true;
	++macrodepth;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0xd62e
movb $0x0, -0x1(%rbp)
jmp 0xd6d4
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xe760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd650
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0xd658
movq -0x10(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xd668
movb $0x0, -0x1(%rbp)
jmp 0xd6d4
movq -0x10(%rbp), %rax
movb 0x5(%rax), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xd695
callq 0xe7b0
testb $0x1, %al
jne 0xd68c
movb $0x0, -0x1(%rbp)
jmp 0xd6d4
movq -0x18(%rbp), %rdi
callq 0xe8a0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xd850
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movq 0x14a0b(%rip), %rax     # 0x220d0
addq $0x1, %rax
movq %rax, 0x14a00(%rip)     # 0x220d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x149e2(%rip), %rsi     # 0x221a8
movl $0x28, %edx
callq 0x3190
callq 0xd540
leaq 0x149cc(%rip), %rax     # 0x221a8
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xd7ee
callq 0xd540
movb $0x1, -0x1(%rbp)
jmp 0xd83f
leaq 0x1489b(%rip), %rdi     # 0x22090
leaq 0x149ac(%rip), %rsi     # 0x221a8
movl $0x28, %edx
callq 0x3190
leaq 0x1499b(%rip), %rdi     # 0x221a8
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
callq 0x3190
movb 0x14874(%rip), %al      # 0x22095
leaq 0x14868(%rip), %rdi     # 0x22090
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0xd850
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: ctxpush
static struct frame *
ctxpush(struct token *t, size_t n, struct macro *m, bool space)
{
	struct frame *f;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq 0x14846(%rip), %rdi     # 0x220b8
movl $0x18, %esi
callq 0x12870
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0xd8b7
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%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/pp.c
// Function: consume
bool
consume(int kind)
{
	if (tok.kind != kind)
		return false;
	next();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x14886(%rip), %rax     # 0x221a8
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
je 0xd92f
movb $0x0, -0x1(%rbp)
jmp 0xd938
callq 0xd540
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: nextinto
static void
nextinto(struct token *t)
{
	static bool newline = true;

	for (;;) {
		scan(t);
		if (newline && t->kind == THASH) {
			directive();
		} else {
			newline = tok.kind == TNEWLINE;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xefb0
testb $0x1, 0x13654(%rip)     # 0x211e0
je 0xdb9e
movq -0x8(%rbp), %rax
cmpl $0x6f, (%rax)
jne 0xdb9e
callq 0xdce0
jmp 0xdbb5
leaq 0x14603(%rip), %rax     # 0x221a8
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movb %al, 0x1362d(%rip)      # 0x211e0
jmp 0xdbb7
jmp 0xdb7c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: macrodone
static void
macrodone(struct macro *m)
{
	m->hide = false;
	if (m->kind == MACROFUNC && m->nparam > 0) {
		free(m->arg[0].token);
		free(m->arg);
	}
	--macrodepth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xdc05
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0xdc05
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3260
movq 0x144c4(%rip), %rax     # 0x220d0
addq $-0x1, %rax
movq %rax, 0x144b9(%rip)     # 0x220d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: macroparam
static size_t
macroparam(struct macro *m, struct token *t)
{
	size_t i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xdcc3
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xdcc1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0xdcb1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdccb
jmp 0xdcb3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdc71
jmp 0xdcc3
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: undef
static void
undef(void)
{
	char *name;
	struct mapkey k;
	void **entry;
	struct macro *m;

	name = tokencheck(&tok, TIDENT, "after #undef");
	mapkey(&k, name, strlen(name));
	entry = mapput(&macros, &k);
	m = *entry;
	if (m) {
		free(name);
		free(m->param);
		free(m->token);
		*entry = NULL;
	}
	scan(&tok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x13cd9(%rip), %rdi     # 0x221a8
movl $0x4, %esi
leaq 0xc926(%rip), %rdx      # 0x1ae01
callq 0x10f20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0xcf70
leaq 0x13b5c(%rip), %rdi     # 0x22068
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)
je 0xe559
movq -0x8(%rbp), %rdi
callq 0x3260
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3260
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3260
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
leaq 0x13c48(%rip), %rdi     # 0x221a8
callq 0xefb0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: macroequal
static bool
macroequal(struct macro *m1, struct macro *m2)
{
	struct macroparam *p1, *p2;
	struct token *t1, *t2;

	if (m1->kind != m2->kind)
		return false;
	if (m1->kind == MACROFUNC) {
		if (m1->nparam != m2->nparam)
			return false;
		for (p1 = m1->param, p2 = m2->param; p1 < m1->param + m1->nparam; ++p1, ++p2) {
			if (strcmp(p1->name, p2->name) != 0 || p1->flags != p2->flags)
				return false;
		}
	}
	if (m1->ntoken != m2->ntoken)
		return false;
	for (t1 = m1->token, t2 = m2->token; t1 < m1->token + m1->ntoken; ++t1, ++t2) {
		if (t1->kind != t2->kind)
			return false;
		if (t1->lit && strcmp(t1->lit, t2->lit) != 0)
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xe5f7
movb $0x0, -0x1(%rbp)
jmp 0xe755
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xe6a6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xe61f
movb $0x0, -0x1(%rbp)
jmp 0xe755
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xe6a4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0xe67f
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xe688
movb $0x0, -0x1(%rbp)
jmp 0xe755
jmp 0xe68a
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0xe637
jmp 0xe6a6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
je 0xe6c1
movb $0x0, -0x1(%rbp)
jmp 0xe755
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq $0x28, 0x38(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xe751
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
je 0xe70a
movb $0x0, -0x1(%rbp)
jmp 0xe755
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xe735
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
je 0xe735
movb $0x0, -0x1(%rbp)
jmp 0xe755
jmp 0xe737
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
jmp 0xe6d9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: peekparen
static bool
peekparen(void)
{
	static struct array pending;
	struct token *t;
	struct frame *f;

	t = ctxnext();
	if (t) {
		if (t->kind == TLPAREN)
			return true;
		f = arraylast(&ctx, sizeof(*f));
		--f->token;
		++f->ntoken;
		return false;
	}
	pending.len = 0;
	do t = arrayadd(&pending, sizeof(*t)), nextinto(t);
	while (t->kind == TNEWLINE);
	if (t->kind == TLPAREN)
		return true;
	t = pending.val;
	ctxpush(t, pending.len / sizeof(*t), NULL, t[0].space);
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xd950
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe813
movq -0x10(%rbp), %rax
cmpl $0x42, (%rax)
jne 0xe7da
movb $0x1, -0x1(%rbp)
jmp 0xe890
leaq 0x138d7(%rip), %rdi     # 0x220b8
movl $0x18, %esi
callq 0x129d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x28, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xe890
movq $0x0, 0x138c2(%rip) # 0x220e0
leaq 0x138b3(%rip), %rdi     # 0x220d8
movl $0x28, %esi
callq 0x12870
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdb70
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0xe81e
movq -0x10(%rbp), %rax
cmpl $0x42, (%rax)
jne 0xe854
movb $0x1, -0x1(%rbp)
jmp 0xe890
movq 0x1387d(%rip), %rax     # 0x220d8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x13876(%rip), %rax     # 0x220e0
movl $0x28, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
movq -0x10(%rbp), %rax
movb 0x5(%rax), %al
xorl %ecx, %ecx
movl %ecx, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0xd850
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/pp.c
// Function: stringize
static void
stringize(struct array *buf, struct token *t)
{
	const char *lit;

	if ((t->space || t->kind == TNEWLINE) && buf->len > 1 && ((char *)buf->val)[buf->len - 1] != ' ')
		arrayaddbuf(buf, " ", 1);
	lit = t->lit ? t->lit : tokstr[t->kind];
	if (t->kind == TSTRINGLIT || t->kind == TCHARCONST) {
		for (; *lit; ++lit) {
			if (*lit == '\\' || *lit == '"')
				arrayaddbuf(buf, "\\", 1);
			arrayaddbuf(buf, lit, 1);
		}
	} else if (lit) {
		arrayaddbuf(buf, lit, strlen(lit));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x5(%rax)
jne 0xec63
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xec9f
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jbe 0xec9f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xec9f
movq -0x8(%rbp), %rdi
leaq 0xddd8(%rip), %rsi      # 0x1ca6d
movl $0x1, %edx
callq 0x12990
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xecb8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xeccf
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x129e9(%rip), %rax     # 0x216b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
je 0xece9
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xed43
jmp 0xeceb
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xed41
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0xed0c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0xed21
movq -0x8(%rbp), %rdi
leaq 0xc161(%rip), %rsi      # 0x1ae78
movl $0x1, %edx
callq 0x12990
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x12990
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xeceb
jmp 0xed75
cmpq $0x0, -0x18(%rbp)
je 0xed73
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x12990
jmp 0xed75
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x48, %edi
callq 0x127c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq 0x132ef(%rip), %rcx     # 0x220f0
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xee19
movq -0x18(%rbp), %rdi
callq 0xee30
movq -0x18(%rbp), %rax
movq %rax, 0x132cc(%rip)     # 0x220f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0xee59
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0xf6a0
jmp 0xee5b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3240
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0xa, (%rax)
jne 0xee97
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0xeefb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpl $0x5c, (%rax)
je 0xeeb2
jmp 0xeefb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3240
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
je 0xeeda
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x31d0
jmp 0xeefb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0xee5b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0x131d5(%rip), %rax     # 0x220f0
cmpq $0x0, 0x8(%rax)
jne 0xef7a
movq 0x131c7(%rip), %rax     # 0x220f0
movq 0x10(%rax), %rdi
leaq 0xc061(%rip), %rsi      # 0x1af95
callq 0x3200
movq %rax, %rcx
movq 0x131ad(%rip), %rax     # 0x220f0
movq %rcx, 0x8(%rax)
movq 0x131a2(%rip), %rax     # 0x220f0
cmpq $0x0, 0x8(%rax)
jne 0xef6e
movq 0x13194(%rip), %rax     # 0x220f0
movq 0x10(%rax), %rsi
leaq 0xbb14(%rip), %rdi      # 0x1aa7b
movb $0x0, %al
callq 0x12650
movq 0x1317b(%rip), %rdi     # 0x220f0
callq 0xee30
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scan.c
// Function: scan
void
scan(struct token *t)
{
	scanner->sawspace = false;
	for (;;) {
		t->kind = scankind(scanner, &t->loc);
		if (t->kind != TEOF || !scanner->next)
			break;
		scanclose();
		scanner = scanner->next;
		scanopen();
	}
	if (scanner->usebuf) {
		t->lit = bufget(&scanner->buf);
		scanner->usebuf = false;
	} else {
		t->lit = NULL;
	}
	t->space = scanner->sawspace;
	t->hide = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1312d(%rip), %rax     # 0x220f0
movb $0x0, 0x5(%rax)
movq 0x13122(%rip), %rdi     # 0x220f0
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0xf080
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xeffa
movq 0x130fd(%rip), %rax     # 0x220f0
cmpq $0x0, 0x40(%rax)
jne 0xeffc
jmp 0xf01a
callq 0xf600
movq 0x130e8(%rip), %rax     # 0x220f0
movq 0x40(%rax), %rax
movq %rax, 0x130dd(%rip)     # 0x220f0
callq 0xef10
jmp 0xefc7
movq 0x130cf(%rip), %rax     # 0x220f0
testb $0x1, 0x4(%rax)
je 0xf04f
movq 0x130c2(%rip), %rdi     # 0x220f0
addq $0x28, %rdi
callq 0xf640
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x130a7(%rip), %rax     # 0x220f0
movb $0x0, 0x4(%rax)
jmp 0xf05b
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq 0x1308e(%rip), %rax     # 0x220f0
movb 0x5(%rax), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scan.c
// Function: bufget
static char *
bufget(struct buffer *b)
{
	char *s;

	bufadd(b, '\0');
	s = xmalloc(b->len);
	memcpy(s, b->str, b->len);
	b->len = 0;

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xf6a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x127c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x3190
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xf717
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf6dd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0xf6e8
movl $0x100, %eax            # imm = 0x100
movq %rax, -0x18(%rbp)
jmp 0xf6e8
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %edx
callq 0x12760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scan.c
// Function: op2
static int
op2(struct scanner *s, int t1, int t2)
{
	nextchar(s);
	if (s->chr != '=')
		return t1;
	nextchar(s);
	return t2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
cmpl $0x3d, (%rax)
je 0xf76c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf77b
movq -0x10(%rbp), %rdi
callq 0xee30
movl -0x18(%rbp), %eax
movl %eax, -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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $-0x1, %eax
je 0xf810
jmp 0xf7bd
movl -0xc(%rbp), %eax
subl $0xa, %eax
je 0xf7fa
jmp 0xf7c7
movl -0xc(%rbp), %eax
subl $0x22, %eax
je 0xf7e6
jmp 0xf7d1
movl -0xc(%rbp), %eax
subl $0x5c, %eax
jne 0xf826
jmp 0xf7db
movq -0x8(%rbp), %rdi
callq 0xfbc0
jmp 0xf82f
movq -0x8(%rbp), %rdi
callq 0xee30
movl $0x7, %eax
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xbb4f(%rip), %rsi      # 0x1b358
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xbb53(%rip), %rsi      # 0x1b372
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rdi
callq 0xee30
jmp 0xf7ad
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
cmpl $0x3d, (%rax)
jne 0xf881
movq -0x10(%rbp), %rdi
callq 0xee30
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8a3
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
je 0xf894
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf8a3
movq -0x10(%rbp), %rdi
callq 0xee30
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $-0x1, %eax
je 0xf930
jmp 0xf8dd
movl -0xc(%rbp), %eax
subl $0xa, %eax
je 0xf91a
jmp 0xf8e7
movl -0xc(%rbp), %eax
subl $0x27, %eax
je 0xf906
jmp 0xf8f1
movl -0xc(%rbp), %eax
subl $0x5c, %eax
jne 0xf946
jmp 0xf8fb
movq -0x8(%rbp), %rdi
callq 0xfbc0
jmp 0xf94f
movq -0x8(%rbp), %rdi
callq 0xee30
movl $0x6, %eax
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xbaa7(%rip), %rsi      # 0x1b3d0
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xbaaf(%rip), %rsi      # 0x1b3ee
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rdi
callq 0xee30
jmp 0xf8cd
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scan.c
// Function: comment
static bool
comment(struct scanner *s)
{
	int last;

	switch (s->chr) {
	case '/':  /* C++-style comment */
		do nextchar(s);
		while (s->chr != '\n' && s->chr != EOF);
		break;
	case '*':  /* C-style comment */
		nextchar(s);
		do {
			last = s->chr;
			nextchar(s);
			if (s->chr == EOF)
				error(&s->loc, "EOF in comment");
		} while (last != '*' || s->chr != '/');
		nextchar(s);
		break;
	default:
		return false;
	}
	s->sawspace = true;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x2a, %eax
je 0xf9b9
jmp 0xf97c
movl -0x18(%rbp), %eax
subl $0x2f, %eax
jne 0xfa1f
jmp 0xf98a
jmp 0xf98c
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0xa, (%rcx)
movb %al, -0x19(%rbp)
je 0xf9b0
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xf98c
jmp 0xfa25
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0xf9f3
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0xba1c(%rip), %rsi      # 0x1b408
movb $0x0, %al
callq 0x11190
jmp 0xf9f5
movb $0x1, %al
cmpl $0x2a, -0x14(%rbp)
movb %al, -0x1a(%rbp)
jne 0xfa0d
movq -0x10(%rbp), %rax
cmpl $0x2f, (%rax)
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xf9c2
movq -0x10(%rbp), %rdi
callq 0xee30
jmp 0xfa25
movb $0x0, -0x1(%rbp)
jmp 0xfa31
movq -0x10(%rbp), %rax
movb $0x1, 0x5(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
cmpl $0x3d, (%rax)
jne 0xfa85
movq -0x10(%rbp), %rdi
callq 0xee30
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfac1
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
je 0xfa98
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfac1
movq -0x10(%rbp), %rdi
callq 0xee30
movq -0x10(%rbp), %rax
cmpl $0x3d, (%rax)
je 0xfab2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfac1
movq -0x10(%rbp), %rdi
callq 0xee30
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)