LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: yyerror
void
yyerror(const char *s)
{
	fprintf(stderr, "%s:%d: %s", filename, curloc.line, s);
	if (curtok->id)
		fprintf(stderr, " near \"%s\"", curtok->id);
	fprintf(stderr, "\n");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x29f3d(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movq 0x48c1b(%rip), %rdx     # 0x7dcd8
movl 0x48c09(%rip), %ecx     # 0x7dccc
movq -0x8(%rbp), %r8
leaq 0x1ea2d(%rip), %rsi     # 0x53afb
movb $0x0, %al
callq 0x6230
movq 0x48c04(%rip), %rax     # 0x7dce0
cmpq $0x0, 0x10(%rax)
je 0x35106
movq 0x29f06(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
movq 0x48bec(%rip), %rax     # 0x7dce0
movq 0x10(%rax), %rdx
leaq 0x1ea06(%rip), %rsi     # 0x53b05
movb $0x0, %al
callq 0x6230
movq 0x29ee3(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq 0x18a9f(%rip), %rsi     # 0x4dbb6
movb $0x0, %al
callq 0x6230
movl $0x1, %edi
callq 0x6310
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: eatspace
static void
eatspace(void)
{
	int c;
	int ignorenl;

	ignorenl = 0;
	while (1) {
		c = peek();
		if (!ignorenl && c == '\n') {
			break;
		} else if (c == '\\') {
			ignorenl = 1;
			next();
		} else if (ignorenl && c == '\n') {
			next();
			curloc.line++;
			ignorenl = 0;
		} else if (isspace(c)) {
			next();
		} else if (c == '/' && peekn(1) == '*') {
			eatcomment();
		} else if (c == '/' && peekn(1) == '/') {
			while (peek() != End && peek() != '\n')
				next();
		} else {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
callq 0x35240
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x35158
cmpl $0xa, -0x4(%rbp)
jne 0x35158
jmp 0x35231
cmpl $0x5c, -0x4(%rbp)
jne 0x3516f
movl $0x1, -0x8(%rbp)
callq 0x35290
jmp 0x3522a
cmpl $0x0, -0x8(%rbp)
je 0x3519b
cmpl $0xa, -0x4(%rbp)
jne 0x3519b
callq 0x35290
movl 0x48b46(%rip), %eax     # 0x7dccc
addl $0x1, %eax
movl %eax, 0x48b3d(%rip)     # 0x7dccc
movl $0x0, -0x8(%rbp)
jmp 0x35228
callq 0x6370
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x351bc
callq 0x35290
jmp 0x35226
cmpl $0x2f, -0x4(%rbp)
jne 0x351d8
movl $0x1, %edi
callq 0x35ae0
cmpl $0x2a, %eax
jne 0x351d8
callq 0x35b20
jmp 0x35224
cmpl $0x2f, -0x4(%rbp)
jne 0x35220
movl $0x1, %edi
callq 0x35ae0
cmpl $0x2f, %eax
jne 0x35220
jmp 0x351ef
callq 0x35240
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x9(%rbp)
je 0x3520e
callq 0x35240
cmpl $0xa, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x35217
jmp 0x3521e
callq 0x35290
jmp 0x351ef
jmp 0x35222
jmp 0x35231
jmp 0x35224
jmp 0x35226
jmp 0x35228
jmp 0x3522a
jmp 0x3522c
jmp 0x3513f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: mktok
static Tok *
mktok(int tt)
{
	Tok *t;

	t = zalloc(sizeof(Tok));
	t->type = tt;
	t->loc = curloc;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x48, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48a4f(%rip), %rcx     # 0x7dccc
movq %rcx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: kwident
static Tok *
kwident(void)
{
	char buf[1024];
	Tok *t;

	if (!identstr(buf, sizeof buf))
		return NULL;
	t = mktok(kwd(buf));
	t->id = strdup(buf);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x35c20
cmpl $0x0, %eax
jne 0x352eb
movq $0x0, -0x8(%rbp)
jmp 0x3532a
leaq -0x410(%rbp), %rdi
callq 0x35cb0
movl %eax, %edi
callq 0x35250
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x418(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x418(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: strlit
static Tok *
strlit(void)
{
	Tok *t;
	int c;
	size_t len, sz;
	char *buf;

	assert(next() == '"');

	buf = NULL;
	len = 0;
	sz = 0;
	while (1) {
		c = next();
		/* we don't unescape here, but on output */
		if (c == '"')
			break;
		else if (c == End)
			lfatal(curloc, "Unexpected EOF within string");
		else if (c == '\n')
			lfatal(curloc, "Newlines not allowed in strings");
		else if (c == '\\')
			decode(&buf, &len, &sz);
		else
			append(&buf, &len, &sz, c);
	};
	t = mktok(Tstrlit);
	t->strval.len = len;

	/* null terminator should not count towards length */
	append(&buf, &len, &sz, '\0');
	t->strval.buf = buf;
	t->id = buf;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x35290
cmpl $0x22, %eax
jne 0x35354
jmp 0x35373
leaq 0x1e80a(%rip), %rdi     # 0x53b65
leaq 0x1e811(%rip), %rsi     # 0x53b73
movl $0x19f, %edx            # imm = 0x19F
leaq 0x1e80b(%rip), %rcx     # 0x53b79
callq 0x6160
movq $0x0, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x35290
movl %eax, -0xc(%rbp)
cmpl $0x22, -0xc(%rbp)
jne 0x3539b
jmp 0x35406
cmpl $-0x1, -0xc(%rbp)
jne 0x353b6
movq 0x48924(%rip), %rdi     # 0x7dccc
leaq 0x1e7dc(%rip), %rsi     # 0x53b8b
movb $0x0, %al
callq 0x1e110
cmpl $0xa, -0xc(%rbp)
jne 0x353d1
movq 0x48909(%rip), %rdi     # 0x7dccc
leaq 0x1e7de(%rip), %rsi     # 0x53ba8
movb $0x0, %al
callq 0x1e110
cmpl $0x5c, -0xc(%rbp)
jne 0x353ea
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x35dc0
jmp 0x353fe
movl -0xc(%rbp), %ecx
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x35f60
jmp 0x35400
jmp 0x35402
jmp 0x35404
jmp 0x3538b
movl $0x138, %edi            # imm = 0x138
callq 0x35250
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x35f60
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: charlit
static Tok *
charlit(void)
{
	Tok *t;
	int c;
	uint32_t val;
	size_t len, sz;
	char *buf;

	assert(next() == '\'');

	buf = NULL;
	len = 0;
	sz = 0;
	val = 0;
	c = next();
	if (c == End)
		lfatal(curloc, "Unexpected EOF within char lit");
	else if (c == '\n')
		lfatal(curloc, "Newlines not allowed in char lit");
	else if (c == '\\')
		val = decode(&buf, &len, &sz);
	else
		val = readutf(c, &buf, &len, &sz);
	append(&buf, &len, &sz, '\0');
	if (next() != '\'')
		lfatal(curloc, "Character constant with multiple characters");

	t = mktok(Tchrlit);
	t->chrval = val;
	t->id = buf;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x35290
cmpl $0x27, %eax
jne 0x35474
jmp 0x35493
leaq 0x1e882(%rip), %rdi     # 0x53cfd
leaq 0x1e6f1(%rip), %rsi     # 0x53b73
movl $0x1e2, %edx            # imm = 0x1E2
leaq 0x1e87e(%rip), %rcx     # 0x53d0c
callq 0x6160
movq $0x0, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x35290
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x354d5
movq 0x48805(%rip), %rdi     # 0x7dccc
leaq 0x1e851(%rip), %rsi     # 0x53d1f
movb $0x0, %al
callq 0x1e110
cmpl $0xa, -0xc(%rbp)
jne 0x354f0
movq 0x487ea(%rip), %rdi     # 0x7dccc
leaq 0x1e855(%rip), %rsi     # 0x53d3e
movb $0x0, %al
callq 0x1e110
cmpl $0x5c, -0xc(%rbp)
jne 0x3550c
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x35dc0
movl %eax, -0x10(%rbp)
jmp 0x35526
movl -0xc(%rbp), %eax
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movsbl %al, %edi
callq 0x363a0
movl %eax, -0x10(%rbp)
jmp 0x35528
jmp 0x3552a
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x35f60
callq 0x35290
cmpl $0x27, %eax
je 0x3555c
movq 0x4877e(%rip), %rdi     # 0x7dccc
leaq 0x1e80a(%rip), %rsi     # 0x53d5f
movb $0x0, %al
callq 0x1e110
movl $0x13a, %edi            # imm = 0x13A
callq 0x35250
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: numlit
static Tok *
numlit(void)
{
	Tok *t;

	/* check for 0x or 0b prefix */
	if (match('0')) {
		if (match('x'))
			t = number(16);
		else if (match('b'))
			t = number(2);
		else if (match('o'))
			t = number(8);
		else {
			unget();
			t = number(10);
		}
	} else {
		t = number(10);
	}

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x3561d
movl $0x78, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x355c6
movl $0x10, %edi
callq 0x364f0
movq %rax, -0x8(%rbp)
jmp 0x3561b
movl $0x62, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x355e5
movl $0x2, %edi
callq 0x364f0
movq %rax, -0x8(%rbp)
jmp 0x35619
movl $0x6f, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x35604
movl $0x8, %edi
callq 0x364f0
movq %rax, -0x8(%rbp)
jmp 0x35617
callq 0x36990
movl $0xa, %edi
callq 0x364f0
movq %rax, -0x8(%rbp)
jmp 0x35619
jmp 0x3561b
jmp 0x3562b
movl $0xa, %edi
callq 0x364f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: typaram
static Tok *
typaram(void)
{
	Tok *t;
	char buf[1024];

	t = NULL;
	if (!match('@'))
		return NULL;
	if (!identstr(buf, 1024))
		return NULL;
	t = mktok(Ttyparam);
	t->id = strdup(buf);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq $0x0, -0x10(%rbp)
movl $0x40, %edi
callq 0x35be0
cmpl $0x0, %eax
jne 0x3566c
movq $0x0, -0x8(%rbp)
jmp 0x356b9
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x35c20
cmpl $0x0, %eax
jne 0x3568c
movq $0x0, -0x8(%rbp)
jmp 0x356b9
movl $0x141, %edi            # imm = 0x141
callq 0x35250
movq %rax, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: eatcomment
static void
eatcomment(void)
{
	int depth;
	int startln;
	int c;

	depth = 0;
	startln = curloc.line;
	while (1) {
		c = next();
		switch (c) {
			/* enter level of nesting */
		case '/':
			if (match('*'))
				depth++;
			break;
			/* leave level of nesting */
		case '*':
			if (match('/'))
				depth--;
			break;
			/* have to keep line numbers synced */
		case '\n': curloc.line++; break;
		case End:
			   lfatal(curloc, "File ended within comment starting at line %d", startln);
			   break;
		}
		if (depth == 0)
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl 0x48197(%rip), %eax     # 0x7dccc
movl %eax, -0x8(%rbp)
callq 0x35290
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $-0x1, %eax
je 0x35bb0
jmp 0x35b4d
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x35b9f
jmp 0x35b57
movl -0x10(%rbp), %eax
subl $0x2a, %eax
je 0x35b85
jmp 0x35b61
movl -0x10(%rbp), %eax
subl $0x2f, %eax
jne 0x35bc8
jmp 0x35b6b
movl $0x2a, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x35b83
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35bc8
movl $0x2f, %edi
callq 0x35be0
cmpl $0x0, %eax
je 0x35b9d
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35bc8
movl 0x48127(%rip), %eax     # 0x7dccc
addl $0x1, %eax
movl %eax, 0x4811e(%rip)     # 0x7dccc
jmp 0x35bc8
movl -0x8(%rbp), %edx
movq 0x48112(%rip), %rdi     # 0x7dccc
leaq 0x1df76(%rip), %rsi     # 0x53b37
movb $0x0, %al
callq 0x1e110
cmpl $0x0, -0x4(%rbp)
jne 0x35bd0
jmp 0x35bd5
jmp 0x35b38
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: match
static int
match(char c)
{
	if (peek() == c) {
		next();
		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
callq 0x35240
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x35c09
callq 0x35290
movl $0x1, -0x4(%rbp)
jmp 0x35c10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: identstr
static int
identstr(char *buf, size_t sz)
{
	size_t i;
	char c;

	i = 0;
	for (c = peek(); i < sz && identchar(c); c = peek()) {
		next();
		buf[i++] = c;
	}
	buf[i] = '\0';
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x35240
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x1a(%rbp)
jae 0x35c61
movsbl -0x19(%rbp), %edi
callq 0x35d70
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x35c6a
jmp 0x35c92
callq 0x35290
movb -0x19(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
callq 0x35240
movb %al, -0x19(%rbp)
jmp 0x35c40
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: decode
static int
decode(char **buf, size_t *len, size_t *sz)
{
	char c, c1, c2;
	int32_t v;

	c = next();
	/* we've already seen the '\' */
	switch (c) {
	case 'u':
		v = unichar();
		appendc(buf, len, sz, v);
		return v;
	case 'x': /* arbitrary hex */
		c1 = next();
		if (!isxdigit(c1))
			lfatal(curloc, "expected hex digit, got %c", c1);
		c2 = next();
		if (!isxdigit(c2))
			lfatal(curloc, "expected hex digit, got %c", c1);
		v = 16 * hexval(c1) + hexval(c2);
		break;
	case 'n': v = '\n'; break;
	case 'r': v = '\r'; break;
	case 't': v = '\t'; break;
	case 'b': v = '\b'; break;
	case '"': v = '\"'; break;
	case '\'': v = '\''; break;
	case 'v': v = '\v'; break;
	case '\\': v = '\\'; break;
	case '0': v = '\0'; break;
	default: lfatal(curloc, "unknown escape code \\%c", c);
	}
	append(buf, len, sz, v);
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x35290
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x56, %eax
ja 0x35f1e
movq -0x30(%rbp), %rax
leaq 0x1da8b(%rip), %rcx     # 0x53888
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x36020
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0x360d0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35f51
callq 0x35290
movb %al, -0x22(%rbp)
callq 0x6370
movq (%rax), %rax
movsbl -0x22(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x35e6b
movsbl -0x22(%rbp), %edx
movq 0x47e6f(%rip), %rdi     # 0x7dccc
leaq 0x1dd64(%rip), %rsi     # 0x53bc8
movb $0x0, %al
callq 0x1e110
callq 0x35290
movb %al, -0x23(%rbp)
callq 0x6370
movq (%rax), %rax
movsbl -0x23(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x35ea9
movsbl -0x22(%rbp), %edx
movq 0x47e31(%rip), %rdi     # 0x7dccc
leaq 0x1dd26(%rip), %rsi     # 0x53bc8
movb $0x0, %al
callq 0x1e110
movsbl -0x22(%rbp), %edi
callq 0x361c0
shll $0x4, %eax
movl %eax, -0x34(%rbp)
movsbl -0x23(%rbp), %edi
callq 0x361c0
movl %eax, %ecx
movl -0x34(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x35f37
movl $0xa, -0x28(%rbp)
jmp 0x35f37
movl $0xd, -0x28(%rbp)
jmp 0x35f37
movl $0x9, -0x28(%rbp)
jmp 0x35f37
movl $0x8, -0x28(%rbp)
jmp 0x35f37
movl $0x22, -0x28(%rbp)
jmp 0x35f37
movl $0x27, -0x28(%rbp)
jmp 0x35f37
movl $0xb, -0x28(%rbp)
jmp 0x35f37
movl $0x5c, -0x28(%rbp)
jmp 0x35f37
movl $0x0, -0x28(%rbp)
jmp 0x35f37
movsbl -0x21(%rbp), %edx
movq 0x47da3(%rip), %rdi     # 0x7dccc
leaq 0x1dcb3(%rip), %rsi     # 0x53be3
movb $0x0, %al
callq 0x1e110
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0x35f60
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: append
static void
append(char **buf, size_t *len, size_t *sz, int c)
{
	if (!*sz) {
		*sz = 16;
		*buf = malloc(*sz);
	}
	if (*len == *sz - 1) {
		*sz = *sz * 2;
		*buf = realloc(*buf, *sz);
	}

	buf[0][*len] = c;
	(*len)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x35fa2
movq -0x18(%rbp), %rax
movq $0x10, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6280
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x35fe7
movq -0x18(%rbp), %rax
movq (%rax), %rcx
shlq %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6290
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: unichar
static int32_t
unichar(void)
{
	uint32_t v;
	int c;

	/* we've already seen the \u */
	if (next() != '{')
		lfatal(curloc, "\\u escape sequence without initial '{'");
	v = 0;
	while (ishexval(peek())) {
		c = next();
		v = 16 * v + hexval(c);
		if (v > 0x10FFFF)
			lfatal(curloc, "invalid codepoint for \\u escape sequence");
	}
	if (next() != '}')
		lfatal(curloc, "\\u escape sequence without ending '}'");
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x35290
cmpl $0x7b, %eax
je 0x36047
movq 0x47c93(%rip), %rdi     # 0x7dccc
leaq 0x1dbbb(%rip), %rsi     # 0x53bfb
movb $0x0, %al
callq 0x1e110
movl $0x0, -0x4(%rbp)
callq 0x35240
movsbl %al, %edi
callq 0x36260
cmpl $0x0, %eax
je 0x360a6
callq 0x35290
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shll $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movsbl %al, %edi
callq 0x361c0
movl %eax, %ecx
movl -0xc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
cmpl $0x10ffff, -0x4(%rbp)   # imm = 0x10FFFF
jbe 0x360a4
movq 0x47c36(%rip), %rdi     # 0x7dccc
leaq 0x1db85(%rip), %rsi     # 0x53c22
movb $0x0, %al
callq 0x1e110
jmp 0x3604e
callq 0x35290
cmpl $0x7d, %eax
je 0x360c5
movq 0x47c15(%rip), %rdi     # 0x7dccc
leaq 0x1db8d(%rip), %rsi     # 0x53c4b
movb $0x0, %al
callq 0x1e110
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: appendc
static void
appendc(char **buf, size_t *len, size_t *sz, uint32_t c)
{
	size_t i, charlen;
	char charbuf[5] = {0};

	if (c < 0x80)
		charlen = 1;
	else if (c < 0x800)
		charlen = 2;
	else if (c < 0x10000)
		charlen = 3;
	else if (c < 0x200000)
		charlen = 4;
	else
		lfatal(curloc, "invalid utf character '\\u{%x}'", c);

	encode(charbuf, charlen, c);
	for (i = 0; i < charlen; i++)
		append(buf, len, sz, charbuf[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x35(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x6180
cmpl $0x80, -0x1c(%rbp)
jae 0x3610a
movq $0x1, -0x30(%rbp)
jmp 0x36161
cmpl $0x800, -0x1c(%rbp)     # imm = 0x800
jae 0x3611d
movq $0x2, -0x30(%rbp)
jmp 0x3615f
cmpl $0x10000, -0x1c(%rbp)   # imm = 0x10000
jae 0x36130
movq $0x3, -0x30(%rbp)
jmp 0x3615d
cmpl $0x200000, -0x1c(%rbp)  # imm = 0x200000
jae 0x36143
movq $0x4, -0x30(%rbp)
jmp 0x3615b
movl -0x1c(%rbp), %edx
movq 0x47b7f(%rip), %rdi     # 0x7dccc
leaq 0x1db1d(%rip), %rsi     # 0x53c71
movb $0x0, %al
callq 0x1e110
jmp 0x3615d
jmp 0x3615f
jmp 0x36161
leaq -0x35(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x362d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x361ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movsbl -0x35(%rbp,%rax), %ecx
callq 0x35f60
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x36179
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: hexval
static int
hexval(char c)
{
	if (c >= 'a' && c <= 'f')
		return c - 'a' + 10;
	else if (c >= 'A' && c <= 'F')
		return c - 'A' + 10;
	else if (c >= '0' && c <= '9')
		return c - '0';
	lfatal(curloc, "passed non-hex value '%c' to where hex was expected", c);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x361ef
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x361ef
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x3624b
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x36210
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x36210
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x3624b
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x3622e
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x3622e
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x3624b
jmp 0x36230
jmp 0x36232
movsbl -0x5(%rbp), %edx
movq 0x47a8f(%rip), %rdi     # 0x7dccc
leaq 0x1da85(%rip), %rsi     # 0x53cc9
movb $0x0, %al
callq 0x1e110
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: ishexval
static int
ishexval(char c)
{
	if (c >= 'a' && c <= 'f')
		return 1;
	else if (c >= 'A' && c <= 'F')
		return 1;
	else if (c >= '0' && c <= '9')
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x36285
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x36285
movl $0x1, -0x4(%rbp)
jmp 0x362c6
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x362a0
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x362a0
movl $0x1, -0x4(%rbp)
jmp 0x362c6
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x362bb
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x362bb
movl $0x1, -0x4(%rbp)
jmp 0x362c6
jmp 0x362bd
jmp 0x362bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: encode
static void
encode(char *buf, size_t len, uint32_t c)
{
	int mark;
	size_t i;

	assert(len > 0 && len < 5);
	if (len == 1)
		mark = 0;
	else
		mark = (((1 << (8 - len)) - 1) ^ 0xff);
	for (i = len - 1; i > 0; i--) {
		buf[i] = (c & 0x3f) | 0x80;
		c >>= 6;
	}
	buf[0] = (c | mark);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x362f3
cmpq $0x5, -0x10(%rbp)
jae 0x362f3
jmp 0x36312
leaq 0x1d996(%rip), %rdi     # 0x53c90
leaq 0x1d872(%rip), %rsi     # 0x53b73
movl $0x115, %edx            # imm = 0x115
leaq 0x1d996(%rip), %rcx     # 0x53ca3
callq 0x6160
cmpq $0x1, -0x10(%rbp)
jne 0x36322
movl $0x0, -0x18(%rbp)
jmp 0x3633f
movl $0x8, %eax
subq -0x10(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
xorl $0xff, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x36381
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3634b
movl -0x14(%rbp), %eax
orl -0x18(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/tok.c
// Function: readutf
static uint32_t
readutf(char c, char **buf, size_t *buflen, size_t *sz)
{
	size_t i, len;
	uint32_t val;

	if ((c & 0x80) == 0)
		len = 1;
	else if ((c & 0xe0) == 0xc0)
		len = 2;
	else if ((c & 0xf0) == 0xe0)
		len = 3;
	else if ((c & 0xf8) == 0xf0)
		len = 4;
	else
		lfatal(curloc, "Invalid utf8 encoded character constant");

	val = c & ((1 << (8 - len)) - 1);
	append(buf, buflen, sz, c);
	for (i = 1; i < len; i++) {
		c = next();
		if ((c & 0xc0) != 0x80)
			lfatal(curloc, "Invalid utf8 codepoint in character literal");
		val = (val << 6) | (c & 0x3f);
		append(buf, buflen, sz, c);
	}
	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsbl -0x1(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x363d2
movq $0x1, -0x30(%rbp)
jmp 0x3643b
movsbl -0x1(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x363ec
movq $0x2, -0x30(%rbp)
jmp 0x36439
movsbl -0x1(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x36406
movq $0x3, -0x30(%rbp)
jmp 0x36437
movsbl -0x1(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x36420
movq $0x4, -0x30(%rbp)
jmp 0x36435
movq 0x478a5(%rip), %rdi     # 0x7dccc
leaq 0x1d95d(%rip), %rsi     # 0x53d8b
movb $0x0, %al
callq 0x1e110
jmp 0x36437
jmp 0x36439
jmp 0x3643b
movsbl -0x1(%rbp), %eax
movl $0x8, %ecx
subq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movsbl -0x1(%rbp), %ecx
callq 0x35f60
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x364e2
callq 0x35290
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x364ad
movq 0x4782d(%rip), %rdi     # 0x7dccc
leaq 0x1d90d(%rip), %rsi     # 0x53db3
movb $0x0, %al
callq 0x1e110
movl -0x34(%rbp), %eax
shll $0x6, %eax
movsbl -0x1(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movsbl -0x1(%rbp), %ecx
callq 0x35f60
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x36476
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: isstacktype
int
isstacktype(Type *t)
{
	t = tybase(t);
	if (t->type == Tyunion)
		return !isenum(t);
	return stackness[t->type];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x36a0d
movq -0x10(%rbp), %rdi
callq 0x36ab0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x36a23
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x45f54(%rip), %rax     # 0x7c970
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tybase
Type *
tybase(Type *t)
{
	assert(t != NULL);
	while (t->type == Tyname || t->type == Tygeneric)
		t = t->sub[0];
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x36a45
jmp 0x36a64
leaq 0x1be7b(%rip), %rdi     # 0x528c7
leaq 0x1d615(%rip), %rsi     # 0x54068
movl $0x1eb, %edx            # imm = 0x1EB
leaq 0x1d63f(%rip), %rcx     # 0x5409e
callq 0x6160
jmp 0x36a66
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x1c, (%rcx)
movb %al, -0x9(%rbp)
je 0x36a81
movq -0x8(%rbp), %rax
cmpl $0x1d, (%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x36a8a
jmp 0x36a9b
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x36a66
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: isenum
int
isenum(Type *t)
{
	size_t i;
	char isenum;

	assert(t->type == Tyunion);

	/* t->isenum is lazily set:
	 * a value of 0 means that it was not computed,
	 * a value of 1 means that the type is an enum
	 * (i.e., it only has nullary constructors)
	 * a value of 2 means that the type is not an enum
	 */
	if (t->isenum == 0) {
		/* initialize it */
		isenum = 1;
		for (i = 0; i < t->nmemb; i++)
			if (t->udecls[i]->etype) {
				isenum = 2;
				break;
			}
		t->isenum = isenum;
	}
	return t->isenum == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x36ac7
jmp 0x36ae6
leaq 0x1b9bc(%rip), %rdi     # 0x5248a
leaq 0x1d593(%rip), %rsi     # 0x54068
movl $0x3b, %edx
leaq 0x1d58e(%rip), %rcx     # 0x5406f
callq 0x6160
movq -0x8(%rbp), %rax
movsbl 0x91(%rax), %eax
cmpl $0x0, %eax
jne 0x36b4d
movb $0x1, -0x11(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x36b40
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x28(%rax)
je 0x36b30
movb $0x2, -0x11(%rbp)
jmp 0x36b40
jmp 0x36b32
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x36b02
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x91(%rax)
movq -0x8(%rbp), %rax
movsbl 0x91(%rax), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: tydedup
Type *
tydedup(Type *ty)
{
	Type *had;

	had = htget(tydeduptab, ty);
	if (!had) {
		htput(tydeduptab, ty, ty);
		return ty;
	}
	/* if one is emitted, both are */
	ty->isemitted = ty->isemitted || had->isemitted;
	return had;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x47175(%rip), %rdi     # 0x7dcf8
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x36bb5
movq 0x4715a(%rip), %rdi     # 0x7dcf8
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x49100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x36bfa
movq -0x10(%rbp), %rax
movsbl 0x96(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x36bde
movq -0x18(%rbp), %rax
movsbl 0x96(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x96(%rax)
movq -0x18(%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/oridb[P]mc/parse/type.c
// Function: mktype
Type *
mktype(Srcloc loc, Ty ty)
{
	Type *t;

	/* the first 'n' types will be identity mapped: tytab[Tyint], eg,
	 * will map to an instantitaion of Tyint.
	 *
	 * This is accomplished at program startup by calling mktype() on
	 * each builtin type in order. As we do this, we put the type into
	 * the table as ususal, which gives us an identity mapping.
	 */
	if (ty <= Tyvalist && ty < ntypes)
		return types[ty];

	t = zalloc(sizeof(Type));
	t->type = ty;
	t->tid = ntypes++;
	t->loc = loc;
	tytab = xrealloc(tytab, ntypes * sizeof(Type *));
	tytab[t->tid] = NULL;
	types = xrealloc(types, ntypes * sizeof(Type *));
	types[t->tid] = t;
	if (ty <= Tyvalist) /* the last builtin atomic type */
		t->vis = Visbuiltin;

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
ja 0x36c48
movl -0x14(%rbp), %eax
cmpq 0x470d1(%rip), %rax     # 0x7dd00
jae 0x36c48
movq 0x470b8(%rip), %rax     # 0x7dcf0
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x36d0a
movl $0xa0, %edi
callq 0x48160
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq 0x4709a(%rip), %rax     # 0x7dd00
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x4708c(%rip)     # 0x7dd00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x47058(%rip), %rdi     # 0x7dce8
movq 0x47069(%rip), %rsi     # 0x7dd00
shlq $0x3, %rsi
callq 0x48240
movq %rax, 0x47041(%rip)     # 0x7dce8
movq 0x4703a(%rip), %rax     # 0x7dce8
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0x4702c(%rip), %rdi     # 0x7dcf0
movq 0x47035(%rip), %rsi     # 0x7dd00
shlq $0x3, %rsi
callq 0x48240
movq %rax, 0x47015(%rip)     # 0x7dcf0
movq -0x20(%rbp), %rdx
movq 0x4700a(%rip), %rax     # 0x7dcf0
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
cmpl $0x11, -0x14(%rbp)
ja 0x36d02
movq -0x20(%rbp), %rax
movl $0x3, 0x10(%rax)
movq -0x20(%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/oridb[P]mc/parse/type.c
// Function: tydup
Type *
tydup(Type *t)
{
	Type *r;

	r = mktype(t->loc, t->type);
	r->resolved = 0;	/* re-resolving doesn't hurt */
	r->fixed = 0;		/* re-resolving doesn't hurt */

	r->arg = memdup(t->arg, t->narg * sizeof(Type *));
	r->narg = t->narg;
	r->inst = memdup(t->arg, t->narg * sizeof(Type *));
	r->ninst = t->ninst;

	r->sub = memdup(t->sub, t->nsub * sizeof(Type *));
	r->nsub = t->nsub;
	r->nmemb = t->nmemb;
	switch (t->type) {
	case Tyname:	r->name = t->name;	break;
	case Tyunres:	r->name = t->name;	break;
	case Tyarray:	r->asize = t->asize;	break;
	case Typaram:	r->pname = strdup(t->pname);	break;
	case Tystruct:	r->sdecls = memdup(t->sdecls, t->nmemb * sizeof(Node *));	break;
	case Tyunion:	r->udecls = memdup(t->udecls, t->nmemb * sizeof(Node *));	break;
	default: break;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq 0x8(%rax), %rdi
callq 0x36c10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %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 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $-0x15, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x36ee7
movq -0x18(%rbp), %rax
leaq 0x1d0d8(%rip), %rcx     # 0x53ef0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
shlq $0x3, %rsi
callq 0x485f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x36ee9
jmp 0x36ee9
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktrait
Trait *
mktrait(Srcloc loc, Node *name, Type *param,
	Type **aux, size_t naux,
	Node **proto, size_t nproto,
	int isproto)
{
	Trait *t;
	size_t i;

	t = zalloc(sizeof(Trait));
	t->uid = ntraittab++;
	t->loc = loc;
	if (t->uid < Ntraits)
		t->vis = Visbuiltin;
	t->vis = Visintern;
	t->name = name;
	t->param = param;
	t->proto = proto;
	t->nproto = nproto;
	t->aux = aux;
	t->env = mkenv();
	t->naux = naux;
	t->isproto = isproto;

	bindtype(t->env, param);
	for (i = 0; i < naux; i++)
		bindtype(t->env, aux[i]);

	for (i = 0; i < nproto; i++)
		if (proto[i]->decl.env)
			proto[i]->decl.env->super = t->env;


	traittab = xrealloc(traittab, ntraittab * sizeof(Trait *));
	traittab[t->uid] = t;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x50, %edi
callq 0x48160
movq %rax, -0x38(%rbp)
movq 0x46dcc(%rip), %rax     # 0x7dd08
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x46dbe(%rip)     # 0x7dd08
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x4(%rax)
movq -0x38(%rbp), %rax
cmpl $0x8, (%rax)
jge 0x36f72
movq -0x38(%rbp), %rax
movl $0x3, 0xc(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x32ee0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movl 0x18(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x48(%rax)
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x348e0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3702b
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x348e0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x36ffa
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq 0x10(%rbp), %rax
jae 0x3707b
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x38(%rax)
je 0x3706b
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
jmp 0x3706d
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x37033
movq 0x46c8e(%rip), %rdi     # 0x7dd10
movq 0x46c7f(%rip), %rsi     # 0x7dd08
shlq $0x3, %rsi
callq 0x48240
movq %rax, 0x46c77(%rip)     # 0x7dd10
movq -0x38(%rbp), %rdx
movq 0x46c6c(%rip), %rax     # 0x7dd10
movq -0x38(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyunres
Type *
mktyunres(Srcloc loc, Node *name, Type **arg, size_t narg)
{
	size_t i;
	Type *t;

	/* resolve it in the type inference stage */
	t = mktype(loc, Tyunres);
	t->name = name;
	t->arg = arg;
	t->narg = narg;
	t->env = mkenv();
	for (i = 0; i < narg; i++)
		bindtype(t->env, arg[i]);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1b, %esi
callq 0x36c10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
callq 0x32ee0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x371da
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x348e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x371a9
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktygeneric
Type *
mktygeneric(Srcloc loc, Node *name, Type **param, size_t nparam, Type *base)
{
	Type *t;
	int i;

	t = mktype(loc, Tygeneric);
	t->name = name;
	t->nsub = 1;
	t->sub = xalloc(sizeof(Type *));
	t->sub[0] = base;
	t->gparam = param;
	t->ngparam = nparam;
	t->env = mkenv();
	for (i = 0; i < nparam; i++)
		bindtype(t->env, param[i]);
	if (!base->env)
		base->env = t->env;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1d, %esi
callq 0x36c10
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x30(%rbp), %rax
movq $0x1, 0x70(%rax)
movl $0x8, %edi
callq 0x481b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
callq 0x32ee0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x372ba
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x348e0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3728c
movq -0x28(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x372d5
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyname
Type *
mktyname(Srcloc loc, Node *name, Type *base)
{
	Type *t;

	t = mktype(loc, Tyname);
	t->name = name;
	t->nsub = 1;
	t->sub = xalloc(sizeof(Type *));
	t->sub[0] = base;
	return t;
}

// 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
movl $0x1c, %esi
callq 0x36c10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x70(%rax)
movl $0x8, %edi
callq 0x481b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyarray
Type *
mktyarray(Srcloc loc, Type *base, Node *sz)
{
	Type *t;

	t = mktype(loc, Tyarray);
	t->nsub = 1;
	t->nmemb = 1; /* the size is a "member" */
	t->sub = xalloc(sizeof(Type *));
	t->sub[0] = base;
	t->asize = sz;

	return t;
}

// 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
movl $0x15, %esi
callq 0x36c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x1, 0x70(%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x78(%rax)
movl $0x8, %edi
callq 0x481b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyslice
Type *
mktyslice(Srcloc loc, Type *base)
{
	Type *t;

	t = mktype(loc, Tyslice);
	t->nsub = 1;
	t->sub = xalloc(sizeof(Type *));
	t->sub[0] = base;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x14, %esi
callq 0x36c10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x1, 0x70(%rax)
movl $0x8, %edi
callq 0x481b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktytuple
Type *
mktytuple(Srcloc loc, Type **sub, size_t nsub)
{
	Type *t;
	size_t i;

	t = mktype(loc, Tytuple);
	t->nsub = nsub;
	t->sub = xalloc(nsub * sizeof(Type *));
	for (i = 0; i < nsub; i++)
		t->sub[i] = sub[i];
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x16, %esi
callq 0x36c10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x481b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x37516
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x374e2
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/parse/type.c
// Function: mktyfunc
Type *
mktyfunc(Srcloc loc, Node **args, size_t nargs, Type *ret)
{
	Type *t;
	size_t i;

	t = mktype(loc, Tyfunc);
	t->nsub = nargs + 1;
	t->sub = xalloc((1 + nargs) * sizeof(Type *));
	t->sub[0] = ret;
	t->env = mkenv();
	for (i = 0; i < nargs; i++)
		t->sub[i + 1] = nodetype(args[i]);
	for (i = 0; i < t->nsub; i++)
		bindtype(t->env, t->sub[i]);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x13, %esi
callq 0x36c10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x481b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, (%rax)
callq 0x32ee0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x375da
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x302b0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3759d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jae 0x3761b
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x348e0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x375e2
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)