LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x2b, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x45, %eax
ja 0xfb2f
movq -0x18(%rbp), %rax
leaq 0xb730(%rip), %rcx      # 0x1b240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x9(%rbp)
jmp 0xfb50
testb $0x1, -0x9(%rbp)
jne 0xfb27
jmp 0xfb52
jmp 0xfb50
movb $0x0, -0x9(%rbp)
jmp 0xfb50
callq 0x3250
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xfb4c
jmp 0xfb52
movb $0x0, -0x9(%rbp)
jmp 0xfae8
movl $0x5, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x4(%rax)
callq 0x3250
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0xfba1
movq -0x8(%rbp), %rax
cmpl $0x5f, (%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xfbaa
jmp 0xfbb5
movq -0x8(%rbp), %rdi
callq 0xee30
jmp 0xfb74
movl $0x4, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
cmpl $0x78, (%rax)
jne 0xfc47
movq -0x8(%rbp), %rdi
callq 0xee30
callq 0x3250
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0xfc1a
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xb775(%rip), %rsi      # 0x1b388
movb $0x0, %al
callq 0x11190
jmp 0xfc1c
movq -0x8(%rbp), %rdi
callq 0xee30
callq 0x3250
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0xfc1c
jmp 0xfcd3
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xfce0
cmpl $0x0, %eax
je 0xfc96
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xfce0
cmpl $0x0, %eax
je 0xfc94
movq -0x8(%rbp), %rdi
callq 0xee30
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xfce0
cmpl $0x0, %eax
je 0xfc92
movq -0x8(%rbp), %rdi
callq 0xee30
jmp 0xfc94
jmp 0xfcd1
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0xb709(%rip), %rdi      # 0x1b3ac
callq 0x30b0
cmpq $0x0, %rax
je 0xfcb9
movq -0x8(%rbp), %rdi
callq 0xee30
jmp 0xfccf
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0xb6f0(%rip), %rsi      # 0x1b3b8
movb $0x0, %al
callq 0x11190
jmp 0xfcd1
jmp 0xfcd3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: scopeinit
void
scopeinit(void)
{
	static struct decl builtins[] = {
		{.name = "__builtin_alloca",      .kind = DECLBUILTIN, .u.builtin = BUILTINALLOCA},
		{.name = "__builtin_constant_p",  .kind = DECLBUILTIN, .u.builtin = BUILTINCONSTANTP},
		{.name = "__builtin_expect",      .kind = DECLBUILTIN, .u.builtin = BUILTINEXPECT},
		{.name = "__builtin_inff",        .kind = DECLBUILTIN, .u.builtin = BUILTININFF},
		{.name = "__builtin_nanf",        .kind = DECLBUILTIN, .u.builtin = BUILTINNANF},
		{.name = "__builtin_offsetof",    .kind = DECLBUILTIN, .u.builtin = BUILTINOFFSETOF},
		{.name = "__builtin_types_compatible_p", .kind = DECLBUILTIN, .u.builtin = BUILTINTYPESCOMPATIBLEP},
		{.name = "__builtin_unreachable", .kind = DECLBUILTIN, .u.builtin = BUILTINUNREACHABLE},
		{.name = "__builtin_va_arg",      .kind = DECLBUILTIN, .u.builtin = BUILTINVAARG},
		{.name = "__builtin_va_copy",     .kind = DECLBUILTIN, .u.builtin = BUILTINVACOPY},
		{.name = "__builtin_va_end",      .kind = DECLBUILTIN, .u.builtin = BUILTINVAEND},
		{.name = "__builtin_va_start",    .kind = DECLBUILTIN, .u.builtin = BUILTINVASTART},
	};
	static struct decl valist;
	struct decl *d;

	for (d = builtins; d < builtins + LEN(builtins); ++d)
		scopeputdecl(&filescope, d);
	valist.name = "__builtin_va_list";
	valist.kind = DECLTYPE;
	valist.type = targ->typevalist;
	scopeputdecl(&filescope, &valist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x114e1(%rip), %rax     # 0x211f0
movq %rax, -0x8(%rbp)
leaq 0x114d6(%rip), %rax     # 0x211f0
addq $0x360, %rax            # imm = 0x360
cmpq %rax, -0x8(%rbp)
jae 0xfd44
movq -0x8(%rbp), %rsi
leaq 0x1240f(%rip), %rdi     # 0x22140
callq 0xfd90
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x8(%rbp)
jmp 0xfd13
leaq 0xb7ae(%rip), %rax      # 0x1b4f9
movq %rax, 0x123a6(%rip)     # 0x220f8
movl $0x0, 0x123a4(%rip)     # 0x22100
leaq 0x1243d(%rip), %rax     # 0x221a0
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x12397(%rip)     # 0x22108
leaq 0x123c8(%rip), %rdi     # 0x22140
leaq 0x12379(%rip), %rsi     # 0x220f8
callq 0xfd90
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: scopeputdecl
void
scopeputdecl(struct scope *s, struct decl *d)
{
	struct mapkey k;

	if (!s->decls.len)
		mapinit(&s->decls, 32);
	mapkey(&k, d->name, strlen(d->name));
	*mapput(&s->decls, &k) = d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xfdbd
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl $0x20, %esi
callq 0xd020
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x30a0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
callq 0xcf70
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0xd190
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: mkscope
struct scope *
mkscope(struct scope *parent)
{
	struct scope *s;

	s = xmalloc(sizeof(*s));
	s->decls.len = 0;
	s->tags.len = 0;
	s->breaklabel = parent->breaklabel;
	s->continuelabel = parent->continuelabel;
	s->switchcases = parent->switchcases;
	s->parent = parent;

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x60, %edi
callq 0x127c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: delscope
struct scope *
delscope(struct scope *s)
{
	struct scope *parent = s->parent;

	if (s->decls.len)
		mapfree(&s->decls, NULL);
	if (s->tags.len)
		mapfree(&s->tags, NULL);
	free(s);

	return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xfec4
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd100
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfedb
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd100
movq -0x8(%rbp), %rdi
callq 0x3260
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: scopegetdecl
struct decl *
scopegetdecl(struct scope *s, const char *name, bool recurse)
{
	struct decl *d;
	struct mapkey k;

	mapkey(&k, name, strlen(name));
	do {
		d = s->decls.len ? mapget(&s->decls, &k) : NULL;
		s = s->parent;
	} while (!d && s && recurse);

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0xcf70
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xff4a
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0xd450
movq %rax, -0x48(%rbp)
jmp 0xff52
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xff52
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
jne 0xff84
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x49(%rbp)
je 0xff84
movb -0x11(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xff28
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: scopegettag
struct type *
scopegettag(struct scope *s, const char *name, bool recurse)
{
	struct type *t;
	struct mapkey k;

	mapkey(&k, name, strlen(name));
	do {
		t = s->tags.len ? mapget(&s->tags, &k) : NULL;
		s = s->parent;
	} while (!t && s && recurse);

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0xcf70
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfff5
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd450
movq %rax, -0x48(%rbp)
jmp 0xfffd
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xfffd
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
jne 0x1002f
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x49(%rbp)
je 0x1002f
movb -0x11(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xffd8
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/scope.c
// Function: scopeputtag
void
scopeputtag(struct scope *s, const char *name, struct type *t)
{
	struct mapkey k;

	if (!s->tags.len)
		mapinit(&s->tags, 32);
	mapkey(&k, name, strlen(name));
	*mapput(&s->tags, &k) = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1006c
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0xd020
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0xcf70
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd190
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/targ.c
// Function: targinit
void
targinit(const char *name)
{
	size_t i;
	enum typequal qual;

	if (!name) {
		/* TODO: provide a way to set this default */
		targ = &alltargs[0];
	}
	for (i = 0; i < LEN(alltargs) && !targ; ++i) {
		if (strcmp(alltargs[i].name, name) == 0)
			targ = &alltargs[i];
	}
	if (!targ)
		fatal("unknown target '%s'", name);
	typechar.u.basic.issigned = targ->signedchar;
	qual = QUALNONE;
	typeadjvalist = typeadjust(targ->typevalist, &qual);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10d81
leaq 0xfd36(%rip), %rax      # 0x20ab0
movq %rax, 0x1141f(%rip)     # 0x221a0
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x3, -0x10(%rbp)
movb %al, -0x15(%rbp)
jae 0x10da5
cmpq $0x0, 0x11403(%rip)     # 0x221a0
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x10dae
jmp 0x10dfa
movq -0x10(%rbp), %rcx
leaq 0xfcf7(%rip), %rax      # 0x20ab0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x10dea
movq -0x10(%rbp), %rcx
leaq 0xfcd4(%rip), %rax      # 0x20ab0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x113b6(%rip)     # 0x221a0
jmp 0x10dec
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x10d89
cmpq $0x0, 0x1139e(%rip)     # 0x221a0
jne 0x10e16
movq -0x8(%rbp), %rsi
leaq 0xab6d(%rip), %rdi      # 0x1b97c
movb $0x0, %al
callq 0x12650
movq 0x11383(%rip), %rax     # 0x221a0
cmpl $0x0, 0x18(%rax)
setne %cl
andb $0x1, %cl
leaq 0x10cba(%rip), %rax     # 0x21ae8
movb %cl, 0x40(%rax)
movl $0x0, -0x14(%rbp)
movq 0x11361(%rip), %rax     # 0x221a0
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x11ed0
movq %rax, %rcx
leaq 0x1137a(%rip), %rax     # 0x221d0
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/token.c
// Function: tokenprint
void
tokenprint(const struct token *t)
{
	const char *str;

	if (t->space)
		fputc(' ', stdout);
	switch (t->kind) {
	case TIDENT:
	case TNUMBER:
	case TCHARCONST:
	case TSTRINGLIT:
		str = t->lit;
		break;
	case TNEWLINE:
		str = "\n";
		break;
	case TEOF:
		return;
	default:
		str = tokstr[t->kind];
	}
	if (!str)
		fatal("cannot print token %d", t->kind);
	fputs(str, stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x10e8a
movq 0x10153(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x3130
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x10ecc
jmp 0x10e9a
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x10ebf
jmp 0x10ea4
movl -0x14(%rbp), %eax
addl $-0x4, %eax
subl $0x3, %eax
ja 0x10ece
jmp 0x10eb1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10ee5
leaq 0x9c2c(%rip), %rax      # 0x1aaf2
movq %rax, -0x10(%rbp)
jmp 0x10ee5
jmp 0x10f13
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x107d3(%rip), %rax     # 0x216b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10f00
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0xab32(%rip), %rdi      # 0x1ba2b
movb $0x0, %al
callq 0x12650
movq -0x10(%rbp), %rdi
movq 0x100c5(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
callq 0x3100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/token.c
// Function: tokencheck
char *
tokencheck(const struct token *t, enum tokenkind kind, const char *msg)
{
	char want[64], got[64];

	if (t->kind != kind) {
		tokendesc(want, sizeof(want), kind, NULL);
		tokendesc(got, sizeof(got), t->kind, t->lit);
		error(&t->loc, "expected %s %s, saw %s", want, msg, got);
	}
	return t->lit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x10f9a
leaq -0x60(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x40, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x10fb0
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movl $0x40, %esi
callq 0x10fb0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0xa0(%rbp), %r8
leaq 0xaaae(%rip), %rsi      # 0x1ba41
movb $0x0, %al
callq 0x11190
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/token.c
// Function: error
void error(const struct location *loc, const char *fmt, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%zu:%zu: error: ", loc->file, loc->line, loc->col);
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	putc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x111c8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xfe05(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0xa844(%rip), %rsi      # 0x1ba58
movb $0x0, %al
callq 0x3180
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xfdb2(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3220
leaq -0x30(%rbp), %rax
movq 0xfd97(%rip), %rax      # 0x20ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3170
movl $0x1, %edi
callq 0x3230
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/tree.c
// Function: treeinsert
void *
treeinsert(void **root, unsigned long long key, size_t sz)
{
	void **a[MAXH];
	struct treenode *n = *root;
	int i = 0;

	a[i++] = root;
	while (n) {
		if (key == n->key) {
			n->new = false;
			return n;
		}
		a[i++] = &n->child[key > n->key];
		n = n->child[key > n->key];
	}
	assert(sz > sizeof(*n));
	n = xmalloc(sz);
	n->key = key;
	n->child[0] = n->child[1] = 0;
	n->height = 1;
	/* insert new node, rebalance ancestors.  */
	*a[--i] = n;
	while (i && balance(a[--i]))
		;
	n->new = true;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x328(%rbp)
movl $0x0, -0x32c(%rbp)
movq -0x10(%rbp), %rcx
movl -0x32c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x32c(%rbp)
cltq
movq %rcx, -0x320(%rbp,%rax,8)
cmpq $0x0, -0x328(%rbp)
je 0x1137e
movq -0x18(%rbp), %rax
movq -0x328(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x11307
movq -0x328(%rbp), %rax
movb $0x0, 0x1c(%rax)
movq -0x328(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11472
movq -0x328(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
movq -0x328(%rbp), %rdx
cmpq (%rdx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
shlq $0x3, %rax
addq %rax, %rcx
movl -0x32c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x32c(%rbp)
cltq
movq %rcx, -0x320(%rbp,%rax,8)
movq -0x328(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x328(%rbp), %rdx
cmpq (%rdx), %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x328(%rbp)
jmp 0x112ce
cmpq $0x20, -0x20(%rbp)
jbe 0x11387
jmp 0x113a6
leaq 0xa71c(%rip), %rdi      # 0x1baaa
leaq 0xa725(%rip), %rsi      # 0x1baba
movl $0x55, %edx
leaq 0xa720(%rip), %rcx      # 0x1bac1
callq 0x30f0
movq -0x20(%rbp), %rdi
callq 0x127c0
movq %rax, -0x328(%rbp)
movq -0x18(%rbp), %rcx
movq -0x328(%rbp), %rax
movq %rcx, (%rax)
movq -0x328(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x328(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x328(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x328(%rbp), %rcx
movl -0x32c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x32c(%rbp)
cltq
movq -0x320(%rbp,%rax,8), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpl $0x0, -0x32c(%rbp)
movb %al, -0x32d(%rbp)
je 0x1144e
movl -0x32c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x32c(%rbp)
cltq
movq -0x320(%rbp,%rax,8), %rdi
callq 0x11480
cmpl $0x0, %eax
setne %al
movb %al, -0x32d(%rbp)
movb -0x32d(%rbp), %al
testb $0x1, %al
jne 0x1145a
jmp 0x1145c
jmp 0x11413
movq -0x328(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x328(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/tree.c
// Function: balance
static int balance(void **p)
{
	struct treenode *n = *p;
	int h0 = height(n->child[0]);
	int h1 = height(n->child[1]);
	if (h0 - h1 + 1u < 3u) {
		int old = n->height;
		n->height = h0 < h1 ? h1 + 1 : h0 + 1;
		return n->height - old;
	}
	return rot(p, n, h0<h1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11530
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11530
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
addl $0x1, %eax
cmpl $0x3, %eax
jae 0x11504
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x114e2
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x114eb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11522
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %edx
callq 0x11560
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: mktype
struct type *
mktype(enum typekind kind, enum typeprop prop)
{
	struct type *t;

	t = xmalloc(sizeof(*t));
	t->kind = kind;
	t->prop = prop;
	t->value = NULL;
	t->incomplete = false;
	t->flexible = false;

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x58, %edi
callq 0x127c0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x3d(%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/type.c
// Function: mkpointertype
struct type *
mkpointertype(struct type *base, enum typequal qual)
{
	struct type *t;

	t = mktype(TYPEPOINTER, PROPSCALAR);
	t->base = base;
	t->qual = qual;
	t->size = 8;
	t->align = 8;
	if (base)
		t->prop |= base->prop & PROPVM;

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xc, %edi
movl $0x10, %esi
callq 0x11700
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x8, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x8, 0x8(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x117ca
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x40, %ecx
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: mkarraytype
struct type *
mkarraytype(struct type *base, enum typequal qual, unsigned long long len)
{
	struct type *t;

	t = mktype(TYPEARRAY, 0);
	t->base = base;
	t->qual = qual;
	t->u.array.length = NULL;
	t->u.array.ptrqual = QUALNONE;
	t->incomplete = !len;
	if (t->base) {
		t->align = t->base->align;
		t->size = t->base->size * len;  /* XXX: overflow? */
	}

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xd, %edi
xorl %esi, %esi
callq 0x11700
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x48(%rax)
cmpq $0x0, -0x18(%rbp)
setne %cl
xorb $-0x1, %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x3c(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1187b
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
imulq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: typepromote
struct type *
typepromote(struct type *t, unsigned width)
{
	if (t == &typefloat)
		return &typedouble;
	if (t->prop & PROPINT && (typerank(t) <= typerank(&typeint) || width <= typeint.size * 8)) {
		if (width == -1)
			width = t->size * 8;
		return width - t->u.basic.issigned < typeint.size * 8 ? &typeint : &typeuint;
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x1039a(%rip), %rax     # 0x21eb0
cmpq %rax, -0x10(%rbp)
jne 0x11b2c
leaq 0x103e5(%rip), %rax     # 0x21f08
movq %rax, -0x8(%rbp)
jmp 0x11bcc
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x11bc4
movq -0x10(%rbp), %rdi
callq 0x11be0
movl %eax, -0x18(%rbp)
leaq 0x1014e(%rip), %rdi     # 0x21ca0
callq 0x11be0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jle 0x11b73
movl -0x14(%rbp), %eax
movq 0x10146(%rip), %rcx     # 0x21cb0
shlq $0x3, %rcx
cmpq %rcx, %rax
ja 0x11bc4
cmpl $-0x1, -0x14(%rbp)
jne 0x11b88
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x3, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movb 0x40(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, %eax
movl %eax, %edx
movq 0x1010b(%rip), %rsi     # 0x21cb0
shlq $0x3, %rsi
leaq 0x10148(%rip), %rax     # 0x21cf8
leaq 0x100e9(%rip), %rcx     # 0x21ca0
cmpq %rsi, %rdx
cmovbq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x11bcc
movq -0x10(%rbp), %rax
movq %rax, -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/type.c
// Function: typerank
static int
typerank(struct type *t)
{
	if (t->kind == TYPEENUM)
		t = t->base;
	assert(t->prop & PROPINT);
	switch (t->kind) {
	case TYPEBOOL:  return 1;
	case TYPECHAR:  return 2;
	case TYPESHORT: return 3;
	case TYPEINT:   return 4;
	case TYPELONG:  return 5;
	case TYPELLONG: return 6;
	}
	fatal("internal error; unhandled integer type");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x11c01
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x11c12
jmp 0x11c31
leaq 0xa076(%rip), %rdi      # 0x1bc8f
leaq 0x9f1f(%rip), %rsi      # 0x1bb3f
movl $0x64, %edx
leaq 0xa0b0(%rip), %rcx      # 0x1bcdc
callq 0x30f0
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x11c8f
movq -0x18(%rbp), %rax
leaq 0x9ea8(%rip), %rcx      # 0x1baf8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x11ca4
movl $0x2, -0x4(%rbp)
jmp 0x11ca4
movl $0x3, -0x4(%rbp)
jmp 0x11ca4
movl $0x4, -0x4(%rbp)
jmp 0x11ca4
movl $0x5, -0x4(%rbp)
jmp 0x11ca4
movl $0x6, -0x4(%rbp)
jmp 0x11ca4
leaq 0xa062(%rip), %rdi      # 0x1bcf8
movb $0x0, %al
callq 0x12650
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: typeadjust
struct type *
typeadjust(struct type *t, enum typequal *tq)
{
	enum typequal ptrqual;

	switch (t->kind) {
	case TYPEARRAY:
		ptrqual = t->u.array.ptrqual;
		t = mkpointertype(t->base, *tq | t->qual);
		*tq = ptrqual;
		break;
	case TYPEFUNC:
		assert(*tq == QUALNONE);
		t = mkpointertype(t, QUALNONE);
		break;
	}

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0xd, %eax
je 0x11efa
jmp 0x11ef0
movl -0x18(%rbp), %eax
subl $0xe, %eax
je 0x11f2d
jmp 0x11f66
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
orl 0x38(%rax), %esi
callq 0x11760
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x11f66
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11f38
jmp 0x11f57
leaq 0x9c8d(%rip), %rdi      # 0x1bbcc
leaq 0x9bf9(%rip), %rsi      # 0x1bb3f
movl $0xe9, %edx
leaq 0x9c8a(%rip), %rcx      # 0x1bbdc
callq 0x30f0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x11760
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: typemember
struct member *
typemember(struct type *t, const char *name, unsigned long long *offset)
{
	struct member *m, *sub;

	assert(t->kind == TYPESTRUCT || t->kind == TYPEUNION);
	for (m = t->u.structunion.members; m; m = m->next) {
		if (m->name) {
			if (strcmp(m->name, name) == 0) {
				*offset += m->offset;
				return m;
			}
		} else {
			sub = typemember(m->type, name, offset);
			if (sub) {
				*offset += m->offset;
				return sub;
			}
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
je 0x11f96
movq -0x10(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x11f98
jmp 0x11fb7
leaq 0x9c75(%rip), %rdi      # 0x1bc14
leaq 0x9b99(%rip), %rsi      # 0x1bb3f
movl $0xf6, %edx
leaq 0x9c90(%rip), %rcx      # 0x1bc42
callq 0x30f0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1205c
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1200b
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x12009
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12064
jmp 0x12049
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11f70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x12047
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12064
jmp 0x12049
jmp 0x1204b
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x11fc3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/type.c
// Function: typehasint
bool
typehasint(struct type *t, unsigned long long i, bool sign)
{
	assert(t->prop & PROPINT);
	if (sign && i >= -1ull << 63)
		return t->u.basic.issigned && i >= -1ull << (t->size << 3) - 1;
	return i <= 0xffffffffffffffffull >> (8 - t->size << 3) + t->u.basic.issigned;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12098
jmp 0x120b7
leaq 0x9bf0(%rip), %rdi      # 0x1bc8f
leaq 0x9a99(%rip), %rsi      # 0x1bb3f
movl $0x10b, %edx            # imm = 0x10B
leaq 0x9bef(%rip), %rcx      # 0x1bca1
callq 0x30f0
testb $0x1, -0x19(%rbp)
je 0x12110
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
jb 0x12110
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x40(%rcx)
movb %al, -0x1a(%rbp)
je 0x12106
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x3, %rcx
subq $0x1, %rcx
movq $-0x1, %rdx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
setae %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1214d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl $0x8, %ecx
subq 0x10(%rdx), %rcx
shlq $0x3, %rcx
movq -0x10(%rbp), %rdx
movb 0x40(%rdx), %dl
andb $0x1, %dl
movzbl %dl, %edx
addq %rdx, %rcx
movq $-0x1, %rdx
shrq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
setbe %al
andb $0x1, %al
movb %al, -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/utf.c
// Function: utf8enc
size_t
utf8enc(unsigned char *s, uint_least32_t c)
{
	if (c < 0x80) {
		s[0] = c;
		return 1;
	}
	if (c < 0x800) {
		s[0] = 0xc0 | c >> 6;
		s[1] = 0x80 | c & 0x3f;
		return 2;
	}
	if (c < 0xd800 || c - 0xe000 < 0x2000) {
		s[0] = 0xe0 | c >> 12;
		s[1] = 0x80 | c >> 6 & 0x3f;
		s[2] = 0x80 | c & 0x3f;
		return 3;
	}
	if (c - 0x10000 < 0x100000) {
		s[0] = 0xf0 | c >> 18;
		s[1] = 0x80 | c >> 12 & 0x3f;
		s[2] = 0x80 | c >> 6 & 0x3f;
		s[3] = 0x80 | c & 0x3f;
		return 4;
	}
	assert(0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0x12190
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x122bd
cmpl $0x800, -0x14(%rbp)     # imm = 0x800
jae 0x121cd
movl -0x14(%rbp), %eax
shrl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq $0x2, -0x8(%rbp)
jmp 0x122bd
cmpl $0xd800, -0x14(%rbp)    # imm = 0xD800
jb 0x121e5
movl -0x14(%rbp), %eax
subl $0xe000, %eax           # imm = 0xE000
cmpl $0x2000, %eax           # imm = 0x2000
jae 0x12230
movl -0x14(%rbp), %eax
shrl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq $0x3, -0x8(%rbp)
jmp 0x122bd
movl -0x14(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
cmpl $0x100000, %eax         # imm = 0x100000
jae 0x1229e
movl -0x14(%rbp), %eax
shrl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq $0x4, -0x8(%rbp)
jmp 0x122bd
leaq 0xa24d(%rip), %rdi      # 0x1c4f2
leaq 0x9a73(%rip), %rsi      # 0x1bd1f
movl $0x1f, %edx
leaq 0x9a6d(%rip), %rcx      # 0x1bd25
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/utf.c
// Function: utf8dec
size_t
utf8dec(uint_least32_t *c, const unsigned char *s, size_t n)
{
	size_t i, l;
	unsigned char b;
	uint_least32_t x;

	b = s[0];
	if (b < 0x80) {
		*c = b;
		return 1;
	}
	if ((b & 0xe0) == 0xc0) {
		x = b & 0x1f;
		l = 2;
	} else if ((b & 0xf0) == 0xe0) {
		x = b & 0x0f;
		l = 3;
	} else if ((b & 0xf8) == 0xf0) {
		x = b & 0x07;
		l = 4;
	} else {
		return -1;
	}
	if (n < l)
		return -1;
	for (i = 1; i < l; ++i) {
		b = *++s;
		if ((b & 0xc0) != 0x80)
			return -1;
		x = x << 6 | b & 0x3f;
	}
	if (x >= 0x110000 || x - 0xd800 < 0x0200)
		return -1;
	*c = x;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x80, %eax
jge 0x1230b
movzbl -0x31(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x12433
movzbl -0x31(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x1232f
movzbl -0x31(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x38(%rbp)
movq $0x2, -0x30(%rbp)
jmp 0x12388
movzbl -0x31(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x12353
movzbl -0x31(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x38(%rbp)
movq $0x3, -0x30(%rbp)
jmp 0x12386
movzbl -0x31(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x12377
movzbl -0x31(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x38(%rbp)
movq $0x4, -0x30(%rbp)
jmp 0x12384
movq $-0x1, -0x8(%rbp)
jmp 0x12433
jmp 0x12386
jmp 0x12388
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1239f
movq $-0x1, -0x8(%rbp)
jmp 0x12433
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x12400
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb 0x1(%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x123e0
movq $-0x1, -0x8(%rbp)
jmp 0x12433
movl -0x38(%rbp), %eax
shll $0x6, %eax
movzbl -0x31(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x123a7
cmpl $0x110000, -0x38(%rbp)  # imm = 0x110000
jae 0x12418
movl -0x38(%rbp), %eax
subl $0xd800, %eax           # imm = 0xD800
cmpl $0x200, %eax            # imm = 0x200
jae 0x12422
movq $-0x1, -0x8(%rbp)
jmp 0x12433
movl -0x38(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/utf.c
// Function: utf16enc
size_t
utf16enc(uint_least16_t *s, uint_least32_t c)
{
	if (c < 0xd800 || c - 0xe000 < 0x2000) {
		s[0] = c;
		return 1;
	}
	c -= 0x10000;
	if (c < 0x100000) {
		s[0] = 0xd800 | c >> 10 & 0x3ff;
		s[1] = 0xdc00 | c & 0x3ff;
		return 2;
	}
	assert(0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0xd800, -0x14(%rbp)    # imm = 0xD800
jb 0x12467
movl -0x14(%rbp), %eax
subl $0xe000, %eax           # imm = 0xE000
cmpl $0x2000, %eax           # imm = 0x2000
jae 0x1247e
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x124ed
movl -0x14(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x14(%rbp)
cmpl $0x100000, -0x14(%rbp)  # imm = 0x100000
jae 0x124ce
movl -0x14(%rbp), %eax
shrl $0xa, %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xd800, %eax           # imm = 0xD800
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl -0x14(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xdc00, %eax           # imm = 0xDC00
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq $0x2, -0x8(%rbp)
jmp 0x124ed
leaq 0xa01d(%rip), %rdi      # 0x1c4f2
leaq 0x9843(%rip), %rsi      # 0x1bd1f
movl $0x56, %edx
leaq 0x986d(%rip), %rcx      # 0x1bd55
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: vwarn
static void
vwarn(const char *fmt, va_list ap)
{
	fprintf(stderr, "%s: ", argv0);
	vfprintf(stderr, fmt, ap);
	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xea41(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq 0xfc17(%rip), %rdx      # 0x221d8
leaq 0x9818(%rip), %rsi      # 0x1bde0
movb $0x0, %al
callq 0x3180
movq 0xea22(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3220
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x12636
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x12636
movq 0xe9da(%rip), %rax      # 0x20ff8
movq (%rax), %rsi
movl $0x20, %edi
callq 0x3130
xorl %eax, %eax
movl %eax, %edi
callq 0x3210
jmp 0x1264a
movq 0xe9bb(%rip), %rax      # 0x20ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3130
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: fatal
void
fatal(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vwarn(fmt, ap);
	va_end(ap);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x12685
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x125a0
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x3230
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: reallocarray
void *
reallocarray(void *buf, size_t n, size_t m)
{
	if (n > 0 && SIZE_MAX / n < m) {
		errno = ENOMEM;
		return NULL;
	}
	return realloc(buf, n * m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x12735
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jae 0x12735
callq 0x3050
movl $0xc, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1274b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x31f0
movq %rax, -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/util.c
// Function: xreallocarray
void *
xreallocarray(void *buf, size_t n, size_t m)
{
	buf = reallocarray(buf, n, m);
	if (!buf && n && m)
		fatal("reallocarray:");

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x126f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x127ac
cmpq $0x0, -0x10(%rbp)
je 0x127ac
cmpq $0x0, -0x18(%rbp)
je 0x127ac
leaq 0x95e2(%rip), %rdi      # 0x1bd87
movb $0x0, %al
callq 0x12650
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: xmalloc
void *
xmalloc(size_t len)
{
	void *buf;

	buf = malloc(len);
	if (!buf && len)
		fatal("malloc:");

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x127f5
cmpq $0x0, -0x8(%rbp)
je 0x127f5
leaq 0x95a7(%rip), %rdi      # 0x1bd95
movb $0x0, %al
callq 0x12650
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: progname
char *
progname(char *name, char *fallback)
{
	char *slash;

	if (!name)
		return fallback;
	slash = strrchr(name, '/');
	return slash ? slash + 1 : name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12821
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12858
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x30e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12848
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12850
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: arrayadd
void *
arrayadd(struct array *a, size_t n)
{
	void *v;

	if (a->cap - a->len < n) {
		do a->cap = a->cap ? a->cap * 2 : 256;
		while (a->cap - a->len < n);
		a->val = realloc(a->val, a->cap);
		if (!a->val)
			fatal("realloc");
	}
	v = (char *)a->val + a->len;
	a->len += n;

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq -0x10(%rbp), %rax
jae 0x1291d
jmp 0x1289c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x128b8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x128c3
movl $0x100, %eax            # imm = 0x100
movq %rax, -0x20(%rbp)
jmp 0x128c3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq -0x10(%rbp), %rax
jb 0x1289c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x31f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1291b
leaq 0x9489(%rip), %rdi      # 0x1bd9d
movb $0x0, %al
callq 0x12650
jmp 0x1291d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: arraylast
void *
arraylast(struct array *a, size_t n)
{
	if (a->len == 0)
		return NULL;
	assert(n <= a->len);
	return (char *)a->val + a->len - n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x129f5
movq $0x0, -0x8(%rbp)
jmp 0x12a40
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x12a05
jmp 0x12a24
leaq 0x9399(%rip), %rdi      # 0x1bda5
leaq 0x939e(%rip), %rsi      # 0x1bdb1
movl $0x7d, %edx
leaq 0x9399(%rip), %rcx      # 0x1bdb8
callq 0x30f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/util.c
// Function: listinsert
void
listinsert(struct list *list, struct list *new)
{
	new->next = list->next;
	new->prev = list;
	list->next->prev = new;
	list->next = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)