LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/scan.c
// Function: scanfrom
void
scanfrom(const char *name, FILE *file)
{
	struct scanner *s;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x48
popq %rdi
callq 0xd0e3
movq %rax, %rbx
movq %r14, 0x8(%rax)
movb $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
movq %r15, 0x10(%rax)
movq $0x1, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x113d2(%rip), %rax     # 0x1c050
movq %rax, 0x40(%rbx)
testq %r14, %r14
je 0xac8f
movq %rbx, %rdi
callq 0xac9c
movq %rbx, 0x113ba(%rip)     # 0x1c050
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/scan.c
// Function: nextchar
static void
nextchar(struct scanner *s)
{
	int c;

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

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

// Assembly:
movq 0x1134f(%rip), %rax     # 0x1c050
cmpq $0x0, 0x8(%rax)
je 0xad09
retq
pushq %rax
movq 0x10(%rax), %rdi
leaq 0x8ea2(%rip), %rsi      # 0x13bb7
callq 0x31e0
movq 0x1132f(%rip), %rdi     # 0x1c050
movq %rax, 0x8(%rdi)
testq %rax, %rax
jne 0xad43
movq 0x10(%rdi), %rsi
leaq 0x8968(%rip), %rdi      # 0x1369d
xorl %eax, %eax
callq 0xcffb
movq 0x1130d(%rip), %rdi     # 0x1c050
popq %rax
jmp 0xac9c
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/scan.c
// Function: bufadd
static void
bufadd(struct buffer *b, int c)
{
	if (b->len >= b->cap) {
		b->cap = b->cap ? b->cap * 2 : 1<<8;
		b->str = xreallocarray(b->str, b->cap, 1);
	}
	b->str[b->len++] = c;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xac9c
leaq 0x10(%rbx), %r14
leaq 0x8abf(%rip), %r15      # 0x13dd2
leaq 0x8a9e(%rip), %r12      # 0x13db8
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xb33f
cmpl $0xa, %eax
je 0xb332
cmpl $0x5c, %eax
je 0xb356
cmpl $0x22, %eax
jne 0xb34c
jmp 0xb360
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xc536
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xc536
movq %rbx, %rdi
callq 0xac9c
jmp 0xb31a
movq %rbx, %rdi
callq 0xb552
jmp 0xb31a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xac9c
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/scan.c
// Function: op3
static int
op3(struct scanner *s, int t1, int t2, int t3)
{
	int c;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x4(%rdi)
callq 0xac9c
leaq 0x10(%rbx), %r14
leaq 0x8a7d(%rip), %r15      # 0x13e4e
leaq 0x8a58(%rip), %r12      # 0x13e30
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0xb3fd
cmpl $0xa, %eax
je 0xb3f0
cmpl $0x5c, %eax
je 0xb414
cmpl $0x27, %eax
jne 0xb40a
jmp 0xb41e
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xc536
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xc536
movq %rbx, %rdi
callq 0xac9c
jmp 0xb3d8
movq %rbx, %rdi
callq 0xb552
jmp 0xb3d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xac9c
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/scan.c
// Function: op4
static int
op4(struct scanner *s, int t1, int t2, int t3, int t4)
{
	int c;

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

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

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

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

	return TIDENT;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xac9c
movl (%rbx), %esi
cmpl $0x78, %esi
jne 0xb5b1
movq %rbx, %rdi
callq 0xac9c
callq 0x3240
movq %rax, %r14
movq (%rax), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xb594
leaq 0x10(%rbx), %rdi
leaq 0x885b(%rip), %rsi      # 0x13de8
xorl %eax, %eax
callq 0xc536
movq %rbx, %rdi
callq 0xac9c
movq (%r14), %rax
movslq (%rbx), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0xb594
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %esi, %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xb5e1
movq %rbx, %rdi
callq 0xac9c
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xb5a9
movq %rbx, %rdi
callq 0xac9c
movl (%rbx), %eax
andl $-0x8, %eax
cmpl $0x30, %eax
jne 0xb5a9
jmp 0xb5f5
leaq 0x8824(%rip), %rdi      # 0x13e0c
pushq $0xc
popq %rdx
callq 0x3120
testq %rax, %rax
je 0xb604
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xac9c
addq $0x10, %rbx
leaq 0x8809(%rip), %rsi      # 0x13e18
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc536
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
leaq 0xfb21(%rip), %r15      # 0x1b150
leaq 0x10a6a(%rip), %rbx     # 0x1c0a0
cmpq $0x35f, %r14            # imm = 0x35F
ja 0xb651
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0xb693
addq $0x48, %r14
jmp 0xb636
leaq 0x8901(%rip), %rax      # 0x13f59
movq %rax, 0x109f9(%rip)     # 0x1c058
andl $0x0, 0x109fa(%rip)     # 0x1c060
leaq 0x109eb(%rip), %rsi     # 0x1c058
leaq 0x10a8c(%rip), %rax     # 0x1c100
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x109e6(%rip)     # 0x1c068
leaq 0x10a17(%rip), %rdi     # 0x1c0a0
popq %rbx
popq %r14
popq %r15
jmp 0xb693
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x20(%rdi), %r14
cmpq $0x0, 0x20(%rdi)
jne 0xb6b7
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x9988
movq (%rbx), %r15
movq %r15, %rdi
callq 0x3090
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x995c
movq %r14, %rdi
movq %r12, %rsi
callq 0x9a5b
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x60
popq %rdi
callq 0xd0e3
andq $0x0, 0x20(%rax)
andq $0x0, (%rax)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x40(%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rbx, 0x58(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58(%rdi), %rbx
cmpq $0x0, 0x20(%rdi)
je 0xb735
leaq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x99ff
cmpq $0x0, (%r14)
je 0xb745
movq %r14, %rdi
xorl %esi, %esi
callq 0x99ff
movq %r14, %rdi
callq 0x3250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3090
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x995c
cmpq $0x0, 0x20(%r14)
je 0xb799
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x9be1
jmp 0xb79b
xorl %eax, %eax
testq %rax, %rax
jne 0xb7ad
movq 0x58(%r14), %r14
testq %r14, %r14
je 0xb7ad
testb %bl, %bl
jne 0xb784
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3090
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x995c
cmpq $0x0, (%r14)
je 0xb7f8
movq %r14, %rdi
movq %r15, %rsi
callq 0x9be1
jmp 0xb7fa
xorl %eax, %eax
testq %rax, %rax
jne 0xb80c
movq 0x58(%r14), %r14
testq %r14, %r14
je 0xb80c
testb %bl, %bl
jne 0xb7e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0xb83d
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x9988
movq %r15, %rdi
callq 0x3090
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x995c
movq %r14, %rdi
movq %r12, %rsi
callq 0x9a5b
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/stmt.c
// Function: label
static bool
label(struct func *f, struct scope *s)
{
	char *name;
	struct gotolabel *g;
	struct block *b;
	unsigned long long i;

	attr(NULL, 0);
	switch (tok.kind) {
	case TCASE:
		next();
		if (!s->switchcases)
			error(&tok.loc, "'case' label must be in switch");
		b = mkblock("switch_case");
		funclabel(f, b);
		i = intconstexpr(s, true);
		switchcase(s->switchcases, i, b);
		expect(TCOLON, "after case expression");
		break;
	case TDEFAULT:
		next();
		if (!s->switchcases)
			error(&tok.loc, "'default' label must be in switch");
		if (s->switchcases->defaultlabel)
			error(&tok.loc, "multiple 'default' labels");
		expect(TCOLON, "after 'default'");
		s->switchcases->defaultlabel = mkblock("switch_default");
		funclabel(f, s->switchcases->defaultlabel);
		break;
	case TIDENT:
		name = tok.lit;
		if (!peek(TCOLON))
			return false;
		g = funcgoto(f, name);
		g->defined = true;
		funclabel(f, g->label);
		break;
	default:
		return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
callq 0x334c
leaq 0xfff0(%rip), %r15      # 0x1c108
movl (%r15), %eax
cmpl $0x4, %eax
je 0xc206
cmpl $0x12, %eax
je 0xc19b
cmpl $0xd, %eax
jne 0xc233
callq 0x9c1e
cmpq $0x0, 0x50(%r14)
jne 0xc153
addq $0x8, %r15
leaq 0x80df(%rip), %rsi      # 0x14228
movq %r15, %rdi
xorl %eax, %eax
callq 0xc536
leaq 0x80ed(%rip), %rdi      # 0x14247
callq 0xd279
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdb62
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6f2d
movq 0x50(%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xd23c
leaq 0x80c5(%rip), %rsi      # 0x14253
pushq $0x5f
popq %rdi
callq 0xa26e
jmp 0xc230
callq 0x9c1e
movq 0x50(%r14), %rax
testq %rax, %rax
jne 0xc1bf
leaq 0x8(%r15), %rdi
leaq 0x80b5(%rip), %rsi      # 0x14269
xorl %eax, %eax
callq 0xc536
movq 0x50(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0xc1db
addq $0x8, %r15
leaq 0x80ba(%rip), %rsi      # 0x1428b
movq %r15, %rdi
xorl %eax, %eax
callq 0xc536
leaq 0x69cd(%rip), %rsi      # 0x12baf
pushq $0x5f
popq %rdi
callq 0xa26e
leaq 0x80b4(%rip), %rdi      # 0x142a5
callq 0xd279
movq 0x50(%r14), %rcx
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xc22b
movq 0x20(%r15), %r14
pushq $0x5f
popq %rdi
callq 0xa18a
testb %al, %al
je 0xc242
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdf5b
movb $0x1, 0x8(%rax)
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xdb62
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
jmp 0xc233
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc28d
movq 0xfe75(%rip), %r14      # 0x1c100
jmp 0xc29b
leaq 0xe7fc(%rip), %r14      # 0x1aa90
movq %r14, 0xfe65(%rip)      # 0x1c100
leaq 0xe7ee(%rip), %r15      # 0x1aa90
xorl %r12d, %r12d
movq %r14, %rax
cmpq $0x2, %r12
ja 0xc2dc
testq %rax, %rax
jne 0xc2dc
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x3140
testl %eax, %eax
je 0xc2c6
xorl %eax, %eax
jmp 0xc2d3
movq %r15, 0xfe33(%rip)      # 0x1c100
movq %r15, %r14
movq %r15, %rax
incq %r12
addq $0x20, %r15
jmp 0xc2a8
testq %rax, %rax
jne 0xc2f9
leaq 0x7fcc(%rip), %rdi      # 0x142b4
movq %rbx, %rsi
xorl %eax, %eax
callq 0xcffb
movq 0xfe07(%rip), %r14      # 0x1c100
cmpl $0x0, 0x18(%r14)
leaq 0xf743(%rip), %rax      # 0x1ba48
setne 0x40(%rax)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq 0x8(%r14), %rdi
callq 0xcba2
leaq 0xfe0f(%rip), %rcx      # 0x1c130
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpb $0x1, 0x5(%rdi)
jne 0xc34c
movq 0xec7f(%rip), %rax      # 0x1afc0
movq (%rax), %rsi
pushq $0x20
popq %rdi
callq 0x3110
movl (%rbx), %esi
leal -0x4(%rsi), %eax
cmpl $0x4, %eax
jae 0xc374
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xc385
leaq 0x7ffa(%rip), %rdi      # 0x14363
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xcffb
jmp 0xc385
cmpl $0x1, %esi
je 0xc398
cmpl $0x2, %esi
jne 0xc39a
leaq 0x738f(%rip), %rbx      # 0x13714
movq 0xec34(%rip), %rax      # 0x1afc0
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x30f0
popq %rbx
retq
leaq 0xf26f(%rip), %rax      # 0x1b610
leaq (%rax,%rsi,8), %rbx
jmp 0xc35a
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
cmpl %esi, (%rdi)
jne 0xc3cf
movq 0x20(%r14), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0xc411
movl (%r14), %esi
movq 0x20(%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0xc411
addq $0x8, %r14
leaq 0x7f7b(%rip), %rsi      # 0x14379
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0xc536
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/token.c
// Function: tokendesc
static void
tokendesc(char *buf, size_t len, enum tokenkind kind, const char *lit)
{
	const char *class;
	bool quote = true;

	switch (kind) {
	case TEOF:       class = "EOF";                       break;
	case TIDENT:     class = "identifier"; quote = true;  break;
	case TNUMBER:    class = "number";     quote = true;  break;
	case TCHARCONST: class = "character";  quote = false; break;
	case TSTRINGLIT: class = "string";     quote = false; break;
	case TNEWLINE:   class = "newline";                   break;
	case TOTHER:     class = NULL;                        break;
	default:
		class = NULL;
		lit = kind < LEN(tokstr) ? tokstr[kind] : NULL;
	}
	if (class && lit)
		snprintf(buf, len, quote ? "%s '%s'" : "%s %s", class, lit);
	else if (class)
		snprintf(buf, len, "%s", class);
	else if (kind == TOTHER && !isprint(*(unsigned char *)lit))
		snprintf(buf, len, "<U+%04x>", *(unsigned char *)lit);
	else if (lit)
		snprintf(buf, len, "'%s'", lit);
	else
		snprintf(buf, len, "<unknown>");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leal -0x1(%rsi), %eax
cmpl $0x6, %eax
ja 0xc48d
movq %rdx, %r14
leaq 0x7f97(%rip), %rdx      # 0x143c1
leaq 0x7eb3(%rip), %rcx      # 0x142e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7f63(%rip), %rcx      # 0x143a4
jmp 0xc4ed
leaq 0x7f5b(%rip), %rcx      # 0x143a8
jmp 0xc4ed
testq %r14, %r14
setne %bpl
callq 0x3240
movq (%rax), %rax
movzbl (%r14), %ecx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0xc4af
leaq 0x7f5c(%rip), %rdx      # 0x143cf
pushq $0x40
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
leaq 0x591f(%rip), %rcx      # 0x11daa
jmp 0xc4ed
cmpl $0x71, %esi
jae 0xc51e
movl %esi, %eax
leaq 0xf171(%rip), %rcx      # 0x1b610
movq (%rcx,%rax,8), %r14
testq %r14, %r14
setne %bpl
cmpl $0x3, %esi
je 0xc459
testb %bpl, %bpl
je 0xc51e
leaq 0x6517(%rip), %rdx      # 0x129d2
pushq $0x40
popq %rsi
movq %rbx, %rdi
movq %r14, %rcx
jmp 0xc513
leaq 0x7eec(%rip), %rcx      # 0x143b9
jmp 0xc4ed
leaq 0x7ef3(%rip), %rdx      # 0x143c9
leaq 0x7ed2(%rip), %rcx      # 0x143af
jmp 0xc4ed
leaq 0x7ee3(%rip), %rdx      # 0x143c9
leaq 0x50ae(%rip), %rcx      # 0x1159b
testq %r14, %r14
je 0xc506
pushq $0x40
popq %rsi
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
leaq 0x64e1(%rip), %rdx      # 0x129ee
pushq $0x40
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
movabsq $0x6e776f6e6b6e753c, %rax # imm = 0x6E776F6E6B6E753C
movq %rax, (%rbx)
movw $0x3e, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0xc595
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xea5c(%rip), %r15      # 0x1aff8
movq (%r15), %rax
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
leaq 0x7ddf(%rip), %rsi      # 0x14390
movq %rax, %rdi
xorl %eax, %eax
callq 0x3160
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x3200
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3150
pushq $0x1
popq %rdi
callq 0x3210
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp            # imm = 0x308
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdi, (%rsp)
xorl %r14d, %r14d
testq %rax, %rax
je 0xc643
cmpq %rbx, (%rax)
je 0xc77c
setb %cl
movzbl %cl, %ecx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp,%r14,8)
movq (%rax), %rax
incq %r14
jmp 0xc61a
cmpq $0x20, %rdx
jbe 0xc793
movq %rdx, %rdi
callq 0xd0e3
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, 0x18(%rax)
movslq %r14d, %rdx
movq (%rsp,%rdx,8), %rcx
movq %rax, (%rcx)
movb $0x1, %cl
testl %edx, %edx
je 0xc77e
decq %r14
pushq $0x1
popq %rdx
pushq $0x2
popq %rsi
movq (%rsp,%r14,8), %rdi
movq (%rdi), %r8
movq 0x8(%r8), %r11
xorl %r9d, %r9d
movl $0x0, %r10d
testq %r11, %r11
je 0xc6a0
movl 0x18(%r11), %r10d
movq 0x10(%r8), %r11
testq %r11, %r11
je 0xc6ad
movl 0x18(%r11), %r9d
movl %r10d, %r11d
subl %r9d, %r11d
incl %r11d
cmpl $0x2, %r11d
ja 0xc6d6
cmpl %r9d, %r10d
cmovgl %r10d, %r9d
incl %r9d
movl %r9d, %ebx
subl 0x18(%r8), %ebx
movl %r9d, 0x18(%r8)
jmp 0xc76c
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl %r9d, %r10d
setge %bl
setl %r15b
movq 0x8(%r8,%r15,8), %r11
movq 0x8(%r11,%rbx,8), %r9
xorl %r12d, %r12d
movl $0x0, %r10d
testq %r9, %r9
je 0xc701
movl 0x18(%r9), %r10d
movq 0x8(%r11,%r15,8), %r13
testq %r13, %r13
je 0xc70f
movl 0x18(%r13), %r12d
movl 0x18(%r8), %ebp
cmpl %r12d, %r10d
jle 0xc749
shll $0x3, %ebx
movq 0x8(%r9,%rbx), %r12
shll $0x3, %r15d
movq %r12, 0x8(%r8,%r15)
movq 0x8(%r9,%r15), %r12
movq %r12, 0x8(%r11,%rbx)
movq %r8, 0x8(%r9,%rbx)
movq %r11, 0x8(%r9,%r15)
movl %r10d, 0x18(%r8)
movl %r10d, 0x18(%r11)
movl %edx, %ebx
jmp 0xc760
movq %r9, 0x8(%r8,%r15,8)
movq %r8, 0x8(%r11,%rbx,8)
leal 0x1(%r10), %r9d
movl %r9d, 0x18(%r8)
movl %esi, %ebx
movq %r11, %r9
addl %r10d, %ebx
movl %ebx, 0x18(%r9)
movq %r9, (%rdi)
subl %ebp, %ebx
addq $-0x1, %r14
jae 0xc77e
testl %ebx, %ebx
jne 0xc683
jmp 0xc77e
xorl %ecx, %ecx
movb %cl, 0x1c(%rax)
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7c48(%rip), %rdi      # 0x143e2
leaq 0x7c51(%rip), %rsi      # 0x143f2
leaq 0x7c51(%rip), %rcx      # 0x143f9
pushq $0x55
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
pushq $0x58
popq %rdi
callq 0xd0e3
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
andq $0x0, 0x18(%rax)
andw $0x0, 0x3c(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0xc
popq %rdi
pushq $0x10
popq %rsi
callq 0xc7b0
movq %rbx, 0x20(%rax)
movl %ebp, 0x38(%rax)
movq $0x8, 0x10(%rax)
movl $0x8, 0x8(%rax)
testq %rbx, %rbx
je 0xc80c
movl 0x4(%rbx), %ecx
andl $0x40, %ecx
orl %ecx, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0xd
popq %rdi
xorl %esi, %esi
callq 0xc7b0
movq %r14, 0x20(%rax)
movl %ebp, 0x38(%rax)
andq $0x0, 0x40(%rax)
andl $0x0, 0x48(%rax)
testq %rbx, %rbx
sete 0x3c(%rax)
testq %r14, %r14
je 0xc855
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rax)
imulq 0x10(%r14), %rbx
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/type.c
// Function: typecompatible
bool
typecompatible(struct type *t1, struct type *t2)
{
	struct decl *p1, *p2;
	struct expr *e1, *e2;

	if (t1 == t2)
		return true;
	if (t1->kind != t2->kind) {
		/*
		enum types are compatible with their underlying
		type, but not with each other (unless they are the
		same type)
		*/
		return t1->kind == TYPEENUM && t2 == t1->base ||
		       t2->kind == TYPEENUM && t1 == t2->base;
	}
	switch (t1->kind) {
	case TYPEPOINTER:
		goto derived;
	case TYPEARRAY:
		if (t1->incomplete || t2->incomplete)
			goto derived;
		e1 = t1->u.array.length;
		e2 = t2->u.array.length;
		if (e1 && e2 && e1->kind == EXPRCONST && e2->kind == EXPRCONST && e1->u.constant.u != e2->u.constant.u)
			return false;
		goto derived;
	case TYPEFUNC:
		if (t1->u.func.isvararg != t2->u.func.isvararg)
			return false;
		for (p1 = t1->u.func.params, p2 = t2->u.func.params; p1 && p2; p1 = p1->next, p2 = p2->next) {
			if (!typecompatible(p1->type, p2->type))
				return false;
		}
		if (p1 || p2)
			return false;
		goto derived;
	derived:
		return t1->qual == t2->qual && typecompatible(t1->base, t2->base);
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %r14, %r15
sete %bl
je 0xc92c
movl (%r15), %eax
movl (%r14), %ecx
cmpl %ecx, %eax
jne 0xc930
cmpl $0xc, %eax
je 0xc915
cmpl $0xe, %eax
je 0xc8d0
cmpl $0xd, %eax
jne 0xc94b
cmpb $0x0, 0x3c(%r15)
jne 0xc915
cmpb $0x0, 0x3c(%r14)
jne 0xc915
movq 0x40(%r15), %rax
testq %rax, %rax
je 0xc915
movq 0x40(%r14), %rcx
testq %rcx, %rcx
je 0xc915
cmpl $0x1, (%rax)
jne 0xc915
cmpl $0x1, (%rcx)
jne 0xc915
movq 0x30(%rax), %rax
cmpq 0x30(%rcx), %rax
je 0xc915
jmp 0xc94b
movb 0x40(%r15), %al
cmpb 0x40(%r14), %al
jne 0xc94b
leaq 0x48(%r15), %r12
leaq 0x48(%r14), %r13
movq (%r12), %r12
movq (%r13), %r13
testq %r12, %r12
je 0xc910
testq %r13, %r13
je 0xc910
movq 0x10(%r12), %rdi
movq 0x10(%r13), %rsi
callq 0xc85a
testb %al, %al
je 0xc94b
addq $0x38, %r12
addq $0x38, %r13
jmp 0xc8e2
orq %r13, %r12
jne 0xc94d
movl 0x38(%r15), %eax
cmpl 0x38(%r14), %eax
jne 0xc94d
movq 0x20(%r15), %r15
movq 0x20(%r14), %r14
jmp 0xc869
movb $0x1, %bl
jmp 0xc94d
cmpl $0x6, %eax
jne 0xc93d
movb $0x1, %bl
cmpq %r14, 0x20(%r15)
je 0xc94d
cmpl $0x6, %ecx
jne 0xc94b
cmpq %r15, 0x20(%r14)
sete %bl
jmp 0xc94d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf4a0(%rip), %rax      # 0x1be10
cmpq %rax, %rdi
je 0xc9e1
movq %rdi, %rbx
testb $0x2, 0x4(%rdi)
je 0xc9e8
movl %esi, %r14d
movq %rbx, %rdi
callq 0xc9f6
movl %eax, %ebp
leaq 0xf26e(%rip), %r15      # 0x1bc00
movq %r15, %rdi
callq 0xc9f6
cmpl %eax, %ebp
jbe 0xc9b1
movl %r14d, %eax
movq 0xf268(%rip), %rcx      # 0x1bc10
shlq $0x3, %rcx
cmpq %rax, %rcx
jb 0xc9e8
cmpl $-0x1, %r14d
jne 0xc9bf
movl 0x10(%rbx), %r14d
shll $0x3, %r14d
movzbl 0x40(%rbx), %eax
subl %eax, %r14d
movq 0xf243(%rip), %rax      # 0x1bc10
shlq $0x3, %rax
cmpq %r14, %rax
leaq 0xf27d(%rip), %rbx      # 0x1bc58
cmovaq %r15, %rbx
jmp 0xc9e8
leaq 0xf480(%rip), %rbx      # 0x1be68
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x6, (%rdi)
jne 0xca00
movq 0x20(%rdi), %rdi
testb $0x2, 0x4(%rdi)
je 0xca3a
movl (%rdi), %eax
addl $-0x2, %eax
cmpl $0x7, %eax
jae 0xca26
pushq $0x6f
popq %rcx
btl %eax, %ecx
jae 0xca26
movl %eax, %eax
leaq 0x7c1b(%rip), %rcx      # 0x1463c
movl (%rcx,%rax,4), %ebx
jmp 0xca36
leaq 0x7be6(%rip), %rdi      # 0x14613
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xcffb
movl %ebx, %eax
popq %rbx
retq
leaq 0x7b69(%rip), %rdi      # 0x145aa
leaq 0x7a12(%rip), %rsi      # 0x1445a
leaq 0x7ba8(%rip), %rcx      # 0x145f7
pushq $0x64
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/type.c
// Function: typecommonreal
struct type *
typecommonreal(struct type *t1, unsigned w1, struct type *t2, unsigned w2)
{
	struct type *tmp;

	assert(t1->prop & PROPREAL && t2->prop & PROPREAL);
	if (t1 == &typeldouble || t2 == &typeldouble)
		return &typeldouble;
	if (t1 == &typedouble || t2 == &typedouble)
		return &typedouble;
	if (t1 == &typefloat || t2 == &typefloat)
		return &typefloat;
	t1 = typepromote(t1, w1);
	t2 = typepromote(t2, w2);
	if (t1 == t2)
		return t1;
	if (t1->u.basic.issigned == t2->u.basic.issigned)
		return typerank(t1) > typerank(t2) ? t1 : t2;
	if (t1->u.basic.issigned) {
		tmp = t1;
		t1 = t2;
		t2 = tmp;
	}
	if (typerank(t1) >= typerank(t2))
		return t1;
	if (t1->size < t2->size)
		return t2;
	if (t2 == &typelong)
		return &typeulong;
	if (t2 == &typellong)
		return &typeullong;
	fatal("internal error; could not find common real type");
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x4, 0x4(%rdi)
je 0xcb83
movq %rdx, %r14
testb $0x4, 0x4(%rdx)
je 0xcb83
movl %ecx, %ebp
leaq 0xf442(%rip), %rbx      # 0x1bec0
cmpq %rbx, %rdi
sete %al
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0xcb75
leaq 0xf3cf(%rip), %rbx      # 0x1be68
cmpq %rbx, %rdi
sete %al
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0xcb75
leaq 0xf35c(%rip), %rbx      # 0x1be10
cmpq %rbx, %rdi
sete %al
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0xcb75
callq 0xc962
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0xc962
cmpq %rax, %rbx
je 0xcb75
movq %rax, %r15
movb 0x40(%rbx), %al
cmpb 0x40(%r15), %al
jne 0xcb09
movq %rbx, %rdi
callq 0xc9f6
movl %eax, %ebp
movq %r15, %rdi
callq 0xc9f6
cmpl %eax, %ebp
cmovbeq %r15, %rbx
jmp 0xcb75
testb %al, %al
movq %r15, %r14
cmovneq %rbx, %r14
cmovneq %r15, %rbx
movq %rbx, %rdi
callq 0xc9f6
movl %eax, %ebp
movq %r14, %rdi
callq 0xc9f6
cmpl %eax, %ebp
jae 0xcb75
movq 0x10(%rbx), %rax
cmpq 0x10(%r14), %rax
jae 0xcb3b
movq %r14, %rbx
jmp 0xcb75
leaq 0xf16e(%rip), %rax      # 0x1bcb0
cmpq %rax, %r14
je 0xcb65
leaq 0xf212(%rip), %rax      # 0x1bd60
cmpq %rax, %r14
je 0xcb6e
leaq 0x795d(%rip), %rdi      # 0x144b7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xcffb
jmp 0xcb75
leaq 0xf19c(%rip), %rbx      # 0x1bd08
jmp 0xcb75
leaq 0xf243(%rip), %rbx      # 0x1bdb8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78a5(%rip), %rdi      # 0x1442f
leaq 0x78c9(%rip), %rsi      # 0x1445a
leaq 0x78c9(%rip), %rcx      # 0x14461
movl $0xbe, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rdi), %eax
cmpl $0xe, %eax
je 0xcbcc
cmpl $0xd, %eax
jne 0xcbde
movl 0x48(%rdi), %ebp
movq 0x20(%rdi), %rax
movl 0x38(%rdi), %esi
orl (%rbx), %esi
movq %rax, %rdi
callq 0xc7d5
movl %ebp, (%rbx)
jmp 0xcbe1
cmpl $0x0, (%rbx)
jne 0xcbe8
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc7d5
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x78f8(%rip), %rdi      # 0x144e7
leaq 0x7864(%rip), %rsi      # 0x1445a
leaq 0x78fa(%rip), %rcx      # 0x144f7
movl $0xe9, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
addl $-0xf, %eax
cmpl $0x2, %eax
jae 0xcc7f
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
addq $0x48, %r14
xorl %r15d, %r15d
movq (%r14), %r14
testq %r14, %r14
je 0xcc70
movq (%r14), %rdi
testq %rdi, %rdi
je 0xcc47
movq %r12, %rsi
callq 0x3140
testl %eax, %eax
jne 0xcc5b
jmp 0xcc61
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xcc07
testq %rax, %rax
jne 0xcc66
addq $0x28, %r14
jmp 0xcc29
movq %r14, %r15
jmp 0xcc69
movq %rax, %r15
movq 0x18(%r14), %rax
addq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x78a9(%rip), %rdi      # 0x1452f
leaq 0x77cd(%rip), %rsi      # 0x1445a
leaq 0x78c9(%rip), %rcx      # 0x1455d
movl $0xf6, %edx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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:
testb $0x2, 0x4(%rdi)
je 0xcce7
testq %rsi, %rsi
setns %al
xorb $0x1, %dl
orb %al, %dl
jne 0xcccc
cmpb $0x1, 0x40(%rdi)
jne 0xcce4
movb 0x10(%rdi), %cl
shlb $0x3, %cl
decb %cl
pushq $-0x1
popq %rax
shlq %cl, %rax
cmpq %rsi, %rax
setbe %al
retq
movl 0x10(%rdi), %eax
movl 0x40(%rdi), %ecx
shll $0x3, %eax
subl %eax, %ecx
pushq $-0x1
popq %rax
shrq %cl, %rax
cmpq %rsi, %rax
setae %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x78bb(%rip), %rdi      # 0x145aa
leaq 0x7764(%rip), %rsi      # 0x1445a
leaq 0x78bf(%rip), %rcx      # 0x145bc
movl $0x10b, %edx            # imm = 0x10B
callq 0x30e0
nop
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x7f, %esi
ja 0xcd17
movb %sil, (%rdi)
pushq $0x1
jmp 0xcdb7
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0xcd38
movl %esi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x1(%rdi)
pushq $0x2
jmp 0xcdb7
cmpl $0xd800, %esi           # imm = 0xD800
setae %al
movl %esi, %ecx
andl $0xffffe000, %ecx       # imm = 0xFFFFE000
cmpl $0xe000, %ecx           # imm = 0xE000
setne %cl
testb %cl, %al
jne 0xcd7b
movl %esi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rdi)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x2(%rdi)
pushq $0x3
jmp 0xcdb7
leal -0x10000(%rsi), %eax
cmpl $0xfffff, %eax          # imm = 0xFFFFF
ja 0xcdb9
movl %esi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rdi)
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rdi)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rdi)
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x3(%rdi)
pushq $0x4
popq %rax
retq
pushq %rax
leaq 0x7f61(%rip), %rdi      # 0x14d22
leaq 0x7890(%rip), %rsi      # 0x14658
leaq 0x788f(%rip), %rcx      # 0x1465e
pushq $0x1f
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xcde8
pushq $0x1
popq %r8
movl %ecx, (%rdi)
movq %r8, %rax
retq
movl %ecx, %r8d
andl $-0x20, %r8d
pushq $-0x1
popq %rax
cmpl $0xc0, %r8d
jne 0xce03
pushq $0x2
popq %r8
pushq $0x1f
jmp 0xce31
movl %ecx, %r8d
andl $-0x10, %r8d
cmpl $0xe0, %r8d
jne 0xce1b
pushq $0x3
popq %r8
pushq $0xf
jmp 0xce31
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0xf0, %r8d
jne 0xcde7
pushq $0x4
popq %r8
pushq $0x7
popq %r9
cmpq %rdx, %r8
ja 0xcde7
andl %r9d, %ecx
pushq $0x1
popq %rdx
cmpq %rdx, %r8
je 0xce67
movzbl (%rsi,%rdx), %r9d
movl %r9d, %r10d
andl $-0x40, %r10d
cmpl $0x80, %r10d
jne 0xcde7
shll $0x6, %ecx
andl $0x3f, %r9d
orl %r9d, %ecx
incq %rdx
jmp 0xce3e
cmpl $0x110000, %ecx         # imm = 0x110000
setae %dl
movl %ecx, %esi
andl $0x1ffe00, %esi         # imm = 0x1FFE00
cmpl $0xd800, %esi           # imm = 0xD800
sete %sil
orb %dl, %sil
je 0xcde2
jmp 0xcde7
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0xd800, %esi           # imm = 0xD800
setae %al
movl %esi, %ecx
andl $0xffffe000, %ecx       # imm = 0xFFFFE000
cmpl $0xe000, %ecx           # imm = 0xE000
setne %cl
testb %cl, %al
jne 0xceb5
movw %si, (%rdi)
pushq $0x1
jmp 0xcedf
leal -0x10000(%rsi), %eax
cmpl $0xfffff, %eax          # imm = 0xFFFFF
ja 0xcee1
shrl $0xa, %eax
orl $0xd800, %eax           # imm = 0xD800
movw %ax, (%rdi)
andl $0x3ff, %esi            # imm = 0x3FF
orl $0xdc00, %esi           # imm = 0xDC00
movw %si, 0x2(%rdi)
pushq $0x2
popq %rax
retq
pushq %rax
leaq 0x7e39(%rip), %rdi      # 0x14d22
leaq 0x7768(%rip), %rsi      # 0x14658
leaq 0x7797(%rip), %rcx      # 0x1468e
pushq $0x56
popq %rdx
callq 0x30e0
nop
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]cproc/util.c
// Function: vwarn
static void
vwarn(const char *fmt, va_list ap)
{
	fprintf(stderr, "%s: ", argv0);
	vfprintf(stderr, fmt, ap);
	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
		fputc(' ', stderr);
		perror(NULL);
	} else {
		fputc('\n', stderr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe05e(%rip), %r15      # 0x1aff8
movq (%r15), %rdi
movq 0xf194(%rip), %rdx      # 0x1c138
leaq 0x776e(%rip), %rsi      # 0x14719
xorl %eax, %eax
callq 0x3160
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3200
cmpb $0x0, (%rbx)
je 0xcfd4
movq %rbx, %rdi
callq 0x3090
cmpb $0x3a, -0x1(%rbx,%rax)
je 0xcfe4
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3110
movq (%r15), %rsi
pushq $0x20
popq %rdi
callq 0x3110
xorl %edi, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x31f0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
callq 0xd083
testq %r14, %r14
je 0xd0cd
testq %rbx, %rbx
je 0xd0cd
testq %rax, %rax
je 0xd0d5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x75e4(%rip), %rdi      # 0x146c0
xorl %eax, %eax
callq 0xcffb