LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/settings.c
// Function: install_setting
static int
install_setting(const char *setting_name, const char *value)
{
	if (setting_name == NULL || value == NULL)
		return EINVAL;
	FOREACH_CDV() {
		if (strings_match(setting_name, cdv->setting_name)) {
			if (cdv->custom_val) {
				return EBUSY;
			} else if (!is_setting_ok(value, cdv->type)) {
				return EINVAL;
			} else {
				cdv->custom_val = xstrdup(value);
				return 0;
			}
		}
	}
	return ENOENT;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x16, %eax
jne 0x80d9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x28, %r15
leaq 0x63eb(%rip), %r12      # 0xe460
movq 0x28(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x4640
testl %eax, %eax
je 0x809a
addq $0x28, %r15
cmpq $0x167, %r15            # imm = 0x167
jbe 0x8075
movl $0x2, %eax
jmp 0x80ce
movl $0x10, %eax
cmpq $0x0, 0x40(%r15,%r12)
jne 0x80ce
movl 0x30(%r15,%r12), %esi
movq %rbx, %rdi
callq 0x78aa
movl %eax, %ecx
movl $0x16, %eax
testb %cl, %cl
je 0x80ce
movq %rbx, %rdi
callq 0x880a
movq %rax, 0x40(%r15,%r12)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/sig.c
// Function: block_signals
void
block_signals(void)
{
	sigset_t set;

	(void) sigemptyset(&set);

	for (struct sig_message_tag *ssp = &sig_message[0];
	    ssp < &sig_message[nitems(sig_message)];
	    ssp++) {
		if (ssp->ignore)
			(void) sigaddset(&set, ssp->num);
	}
	if (sigprocmask(SIG_BLOCK, &set, NULL) != 0)
		fatal(errno, "%s: pthread_sigmask", __func__);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4570
movq $-0x20, %r14
leaq 0x5a8f(%rip), %r15      # 0xdb90
cmpb $0x1, 0x30(%r14,%r15)
jne 0x8116
movl 0x20(%r14,%r15), %esi
movq %rbx, %rdi
callq 0x46b0
addq $0x20, %r14
cmpq $0x1a0, %r14            # imm = 0x1A0
jb 0x8101
movq %rsp, %rsi
xorl %edi, %edi
xorl %edx, %edx
callq 0x41e0
testl %eax, %eax
jne 0x8140
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x4050
movl (%rax), %edi
leaq 0x2de4(%rip), %rsi      # 0xaf32
leaq 0x2df1(%rip), %rdx      # 0xaf46
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/sig.c
// Function: program_clean_up
void
program_clean_up(void)
{
	net_deinit();
	destroy_config_custom_values();

	if (g_conf_read)
		log_msg("%s %s has exited", g_programName, g_programVersion);
	if (g_lockfile_fd != -1)
		close(g_lockfile_fd);
	if (g_log_to_syslog)
		closelog();
}

// Assembly:
pushq %rax
callq 0x75b6
callq 0x7eb5
leaq 0x6682(%rip), %rax      # 0xe7f0
cmpb $0x1, (%rax)
jne 0x818f
leaq 0x2dda(%rip), %rdi      # 0xaf54
leaq 0x12bf(%rip), %rsi      # 0x9440
leaq 0x12c5(%rip), %rdx      # 0x944d
xorl %eax, %eax
callq 0x588a
leaq 0x628a(%rip), %rax      # 0xe420
movl (%rax), %edi
cmpl $-0x1, %edi
je 0x81a2
callq 0x4800
leaq 0x6568(%rip), %rax      # 0xe711
cmpb $0x1, (%rax)
jne 0x81b4
popq %rax
jmp 0x43f0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/sig.c
// Function: sighand_init
int
sighand_init(void)
{
	sigset_t		 set;
	struct sigaction	 act = { 0 };

	(void) sigfillset(&set);
	(void) sigfillset(&act.sa_mask);
	act.sa_flags = 0;

	if (sigprocmask(SIG_SETMASK, &set, NULL) != 0) {
		log_warn(errno, "%s: SIG_SETMASK", __func__);
		return -1;
	}

	for (struct sig_message_tag *ssp = &sig_message[0];
	    ssp < &sig_message[nitems(sig_message)];
	    ssp++) {
		if (ssp->ignore) {
			act.sa_handler = SIG_IGN;
		} else {
			act.sa_handler = handle_signals;
		}
		if (sigaction(ssp->num, &act, NULL) != 0) {
			log_warn(errno, "%s: sigaction failed on signal %d "
			    "(%s)", __func__, ssp->num, ssp->num_str);
			return -1;
		}
	}

	(void) sigemptyset(&set);

	if (sigprocmask(SIG_SETMASK, &set, NULL) != 0) {
		log_warn(errno, "%s: SIG_SETMASK", __func__);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsp, %rdi
movl $0x98, %edx
xorl %esi, %esi
callq 0x4220
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x4140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4140
movl $0x0, 0x80(%r14)
movl $0x2, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x41e0
testl %eax, %eax
je 0x8232
callq 0x4050
movl (%rax), %edi
leaq 0x2d46(%rip), %rsi      # 0xaf65
leaq 0x2d4f(%rip), %rdx      # 0xaf75
xorl %eax, %eax
callq 0x591f
jmp 0x82d1
movq $-0x20, %r14
leaq 0x5950(%rip), %r15      # 0xdb90
leaq 0xa3(%rip), %r12        # 0x82ea
movl $0x1, %r13d
movq %rsp, %rbx
cmpb $0x0, 0x30(%r14,%r15)
movq %r12, %rax
cmovneq %r13, %rax
movq %rax, (%rsp)
movl 0x20(%r14,%r15), %ebp
movl %ebp, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4580
testl %eax, %eax
jne 0x82ae
addq $0x20, %r14
cmpq $0x19f, %r14            # imm = 0x19F
jbe 0x8250
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x4570
xorl %ebx, %ebx
movl $0x2, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x41e0
testl %eax, %eax
jne 0x8211
jmp 0x82d6
callq 0x4050
movl (%rax), %edi
movq 0x28(%r14,%r15), %r8
leaq 0x2cc1(%rip), %rsi      # 0xaf82
leaq 0x2cad(%rip), %rdx      # 0xaf75
movl %ebp, %ecx
xorl %eax, %eax
callq 0x591f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/sig.c
// Function: handle_signals
static void
handle_signals(int signum)
{
	program_clean_up();

	for (struct sig_message_tag *ssp = &sig_message[0];
	    ssp < &sig_message[nitems(sig_message)];
	    ssp++) {
		if (ssp->num == signum) {
			log_warn(0, "Received signal %d (%s): %s", ssp->num,
			    ssp->num_str, ssp->msg);
		}
	}

	_exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x815c
movq $-0x20, %r15
leaq 0x5889(%rip), %r12      # 0xdb90
leaq 0x2e43(%rip), %r14      # 0xb151
movl 0x20(%r15,%r12), %edx
cmpl %ebx, %edx
jne 0x832d
movq 0x28(%r15,%r12), %rcx
movq 0x38(%r15,%r12), %r8
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x591f
addq $0x20, %r15
cmpq $0x1a0, %r15            # imm = 0x1A0
jb 0x830e
movl $0x1, %edi
callq 0x4720
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/various.c
// Function: is_numeric
bool
is_numeric(const char *string)
{
	if (string == NULL || *string == '\0') {
		return false;
	}
	for (const char *p = &string[0]; *p != '\0'; p++) {
		if (!isdigit(*p))
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8534
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x8534
movsbq (%rbx), %r14
testq %r14, %r14
sete %bpl
je 0x8536
callq 0x4470
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r14,2)
je 0x8536
incq %rbx
movsbq (%rbx), %rcx
testq %rcx, %rcx
sete %bpl
je 0x8536
incq %rbx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x851b
jmp 0x8536
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/various.c
// Function: strToLower
char *
strToLower(char *s)
{
	size_t len = 0;

	if (s == NULL) {
		fatal(EINVAL, "strToLower");
	} else if (*s == '\0') {
		return s;
	} else {
		len = strlen(s);
	}
	for (char *p = &s[0]; p < &s[len]; p++) {
		if (isupper(*p))
			*p = tolower(*p);
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8606
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x85f9
movq %rbx, %rdi
callq 0x41c0
testq %rax, %rax
jle 0x85f9
movq %rax, %r14
addq %rbx, %r14
callq 0x4470
movq %rax, %r15
movq %rbx, %r12
movq (%r15), %rax
movsbq (%r12), %r13
testb $0x1, 0x1(%rax,%r13,2)
je 0x85f1
callq 0x40c0
movq (%rax), %rax
movb (%rax,%r13,4), %al
movb %al, (%r12)
incq %r12
cmpq %r14, %r12
jb 0x85d1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2b75(%rip), %rsi      # 0xb182
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/various.c
// Function: trim
char *
trim(char *string)
{
	if (string == NULL) {
		fatal(EINVAL, "trim");
	} else if (*string == '\0') {
		return string;
	} else {
		char *p;

		for (p = &string[strlen(string) - 1]; p >= &string[0]; p--) {
			if (!isspace(*p))
				break;
		}

		*(p + 1) = '\0';
	}
	return string;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8667
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x865c
movq %rbx, %rdi
callq 0x41c0
addq %rbx, %rax
decq %rax
movq %rax, %r14
cmpq %rbx, %rax
jb 0x8657
callq 0x4470
movq (%rax), %rcx
movsbq (%r14), %rdx
leaq -0x1(%r14), %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x8638
movb $0x0, 0x1(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2b1f(%rip), %rsi      # 0xb18d
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/various.c
// Function: toggle_echo
void
toggle_echo(on_off_t state)
{
	struct termios term_attrs = { 0 };

	errno = 0;

	if (tcgetattr(STDIN_FILENO, &term_attrs) != 0)
		fatal(errno, "%s: tcgetattr", __func__);

	switch (state) {
	case ON:
		if (!(term_attrs.c_lflag & ECHO)) {
			term_attrs.c_lflag |= ECHO;
			if (tcsetattr(STDIN_FILENO, TCSANOW, &term_attrs) != 0)
				fatal(errno, "%s: tcsetattr", __func__);
		}
		break;
	case OFF:
		if (term_attrs.c_lflag & ECHO) {
			term_attrs.c_lflag &= ~ECHO;
			if (tcsetattr(STDIN_FILENO, TCSANOW, &term_attrs) != 0)
				fatal(errno, "%s: tcsetattr", __func__);
		}
		break;
	default:
		fatal(0, "%s: statement reached unexpectedly", __func__);
		break;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r14
movups %xmm0, 0x2c(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
callq 0x4050
movq %rax, %rbx
movl $0x0, (%rax)
xorl %edi, %edi
movq %r14, %rsi
callq 0x44d0
testl %eax, %eax
jne 0x871f
cmpl $0x1, %ebp
je 0x86f8
testl %ebp, %ebp
jne 0x872a
movl 0xc(%rsp), %eax
testb $0x8, %al
jne 0x8716
orl $0x8, %eax
jmp 0x8703
movl 0xc(%rsp), %eax
testb $0x8, %al
je 0x8716
andl $-0x9, %eax
movq %rsp, %rdx
movl %eax, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x45a0
testl %eax, %eax
jne 0x873c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl (%rbx), %edi
leaq 0x2a9d(%rip), %rsi      # 0xb1c5
jmp 0x8745
leaq 0x2abc(%rip), %rsi      # 0xb1ed
leaq 0x2a9b(%rip), %rdx      # 0xb1d3
xorl %edi, %edi
jmp 0x874c
movl (%rbx), %edi
leaq 0x2a9a(%rip), %rsi      # 0xb1df
leaq 0x2a87(%rip), %rdx      # 0xb1d3
xorl %eax, %eax
callq 0x563c
nop
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/wrapper.c
// Function: strdup_printf
char *
strdup_printf(const char *format, ...)
{
	char		*ret;
	int		 chars_printed;
	va_list		 ap;

	va_start(ap, format);
	chars_printed = my_vasprintf(&ret, format, ap);
	va_end(ap);

	if (chars_printed < 0)
		fatal(errno, "strdup_printf");

	return ret;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, %r10
leaq 0x30(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x87b5
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
movq %r10, %rsi
callq 0x64cc
testl %eax, %eax
js 0x87f5
movq 0x8(%rsp), %rax
addq $0xe8, %rsp
retq
callq 0x4050
movl (%rax), %edi
leaq 0x2a0d(%rip), %rsi      # 0xb210
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/wrapper.c
// Function: xstrdup
char *
xstrdup(const char *s)
{
	char	*newstr = NULL;
	size_t	 sz = 0;

	if (s == NULL) {
		fatal(EINVAL, "%s: invalid argument", __func__);
	} else {
		sz = strlen(s) + 1;
	}

	if ((newstr = malloc(sz)) == NULL)
		fatal(ENOMEM, "%s: error allocating %zu bytes", __func__, sz);
	if (strlcpy(newstr, s, sz) >= sz)
		fatal(EOVERFLOW, "%s: truncated", __func__);
	return (newstr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x884e
movq %rdi, %r14
callq 0x41c0
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x45e0
testq %rax, %rax
je 0x8863
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x83c0
cmpq %rbx, %rax
jae 0x8880
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x29c9(%rip), %rsi      # 0xb21e
leaq 0x29d7(%rip), %rdx      # 0xb233
movl $0x16, %edi
jmp 0x8893
leaq 0x29d1(%rip), %rsi      # 0xb23b
leaq 0x29c2(%rip), %rdx      # 0xb233
movl $0xc, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x563c
leaq 0x29d3(%rip), %rsi      # 0xb25a
leaq 0x29a5(%rip), %rdx      # 0xb233
movl $0x4b, %edi
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/wrapper.c
// Function: xcalloc
void *
xcalloc(size_t elt_count, size_t elt_size)
{
	void *vp = NULL;

	if (elt_count == 0) {
		fatal(EINVAL, "xcalloc: invalid argument: "
		    "element count is zero");
	} else if (elt_size == 0) {
		fatal(EINVAL, "xcalloc: invalid argument: "
		    "element size is zero");
	} else if (SIZE_MAX / elt_count < elt_size) {
		fatal(0, "xcalloc: integer overflow");
	} else {
		if ((vp = calloc(elt_count, elt_size)) == NULL) {
			fatal(ENOMEM, "xcalloc: out of memory "
			    "(allocating %zu bytes)", (elt_count * elt_size));
		}
	}

	return (vp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88ce
movq %rsi, %rbx
testq %rsi, %rsi
je 0x88d7
movq %rdi, %r14
movq %rdi, %rax
mulq %rbx
jo 0x88e5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42b0
testq %rax, %rax
je 0x88f5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2993(%rip), %rsi      # 0xb268
jmp 0x88de
leaq 0x29bb(%rip), %rsi      # 0xb299
movl $0x16, %edi
jmp 0x88ee
leaq 0x29dd(%rip), %rsi      # 0xb2c9
xorl %edi, %edi
xorl %eax, %eax
callq 0x563c
imulq %r14, %rbx
leaq 0x29e3(%rip), %rsi      # 0xb2e3
movl $0xc, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/wrapper.c
// Function: xmalloc
void *
xmalloc(size_t size)
{
	void *vp = NULL;

	if (size == 0) {
		fatal(EINVAL, "xmalloc: invalid argument -- zero size");
	}

	if ((vp = malloc(size)) == NULL) {
		fatal(ENOMEM, "xmalloc: error allocating %zu bytes", size);
	}

	return (vp);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8924
movq %rdi, %rbx
callq 0x45e0
testq %rax, %rax
je 0x8937
popq %rbx
retq
leaq 0x29e6(%rip), %rsi      # 0xb311
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
leaq 0x29fa(%rip), %rsi      # 0xb338
movl $0xc, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x563c
// File: /workspace/github_c_makefile_star2_O1/uhlin[P]enhanced-duc/source/wrapper.c
// Function: xrealloc
void *
xrealloc(void *ptr, size_t newSize)
{
	void *newPtr = NULL;

	if (ptr == NULL) {
		fatal(EINVAL, "xrealloc: invalid argument: "
		    "a null pointer was passed");
	} else if (newSize == 0) {
		fatal(EINVAL, "xrealloc: invalid argument: "
		    "zero size  --  use free");
	} else {
		if ((newPtr = realloc(ptr, newSize)) == NULL) {
			fatal(errno, "xrealloc: error changing memory block "
			    "to %zu bytes", newSize);
		}
	}

	return (newPtr);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x896a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8973
movq %rbx, %rsi
callq 0x4740
testq %rax, %rax
je 0x8986
popq %rbx
retq
leaq 0x29eb(%rip), %rsi      # 0xb35c
jmp 0x897a
leaq 0x2a18(%rip), %rsi      # 0xb392
movl $0x16, %edi
xorl %eax, %eax
callq 0x563c
callq 0x4050
movl (%rax), %edi
leaq 0x2a32(%rip), %rsi      # 0xb3c6
movq %rbx, %rdx
xorl %eax, %eax
callq 0x563c
nop
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/main.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "argc: %d shoule be 2", argc);
        return 1;
    }

    int exit_code = 1;
    char *fpath = argv[1];

    printf("C => %s\n", fpath);
    FILE *fp = fopen(fpath, "rb");
    if (fp == NULL) {
        fprintf(stderr, "Failed to open file: ");
        goto exit_0;
    }

    char *fcontent = read_all(fp);
    fclose(fp);

    printf("%s\n", fcontent);

    CC* cc = cc_new(fcontent, fpath);

    ParserResult res = cc_parse(cc);
    if (res.result == PARSER_ERROR) {
        fprintf(stderr, "ERROR: ");
        parser_fprint_error(stderr, &res.error);
        fprintf(stderr, "\n");
        goto exit;
    }
    assert(res.value.node);

    printf("= AST =\n");
    node_fprint(stdout, res.value.node);
    printf("\n");

    /*AnalyzerResult res = */cc_analyze(cc, res.value.node);
    /* TODO: error check */

    int err =
    /*CompileResult res = */cc_compile(cc, res.value.node);
    if (err) {
        goto exit;
    }

    exit_code = 0; // Success

exit:
    cc_drop(cc);

exit_0:
    free(fcontent);

    return exit_code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x2, %edi
jne 0x1739
movq 0x8(%rsi), %r14
leaq 0x59fd(%rip), %rdi      # 0x7019
movq %r14, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x59f5(%rip), %rsi      # 0x7022
movq %r14, %rdi
callq 0x1190
testq %rax, %rax
je 0x1769
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1170
movq %r15, %rdi
callq 0x1120
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1170
leaq 0x1(%r12), %rdi
callq 0x1150
movq %rax, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1080
movb $0x0, (%rbx,%r12)
movq %r15, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62dc
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x63bf
cmpl $0x1, (%r15)
je 0x175a
cmpq $0x0, 0x18(%rsp)
je 0x176e
leaq 0x599b(%rip), %rdi      # 0x7070
callq 0x1070
movq 0x98f7(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x326c
movl $0xa, %edi
callq 0x1050
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x649e
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x64d1
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
movq %r14, %rdi
callq 0x6312
movq %rbx, %rdi
callq 0x1040
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %edx
movq 0x98b6(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x58b8(%rip), %rsi      # 0x7004
xorl %eax, %eax
callq 0x1110
movl $0x1, %ebp
jmp 0x172a
movq %rsp, %rdi
callq 0x11d0
movl $0x1, %ebp
jmp 0x171a
callq 0x1215
leaq 0x58ce(%rip), %rdi      # 0x7043
leaq 0x58d6(%rip), %rsi      # 0x7052
leaq 0x58d6(%rip), %rcx      # 0x7059
movl $0x36, %edx
callq 0x10d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/lexer.c
// Function: lexer_new
Lexer* lexer_new(const char *buffer, const char* filepath) {
    Lexer* lex = (Lexer*)malloc(sizeof(Lexer));
    lex->buffer = buffer;
    lex->current_pos = 0;
    lex->begin_pos = -1;
    lex->filepath = filepath;

    return lex;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x1150
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
movq $-0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/token.c
// Function: token_to_string
char* token_to_string(Token *tok) {
    size_t range_size = tok->pos_end - tok->pos_begin;
    char* range = malloc(sizeof(char) * (range_size + 1));
    memcpy(range, tok->buf_ref + tok->pos_begin, range_size);
    range[range_size] = '\0';

    return range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
subq %r14, %r15
leaq 0x1(%r15), %rdi
callq 0x1150
movq %rax, %r12
addq 0x8(%rbx), %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1140
movb $0x0, (%r12,%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/token.c
// Function: token_fprint
void token_fprint(FILE *fp, Token *tok) {
    switch(tok->kind) {
    case TOK_KIND_SHARP:
        fprintf(fp, "#");
        break;
    case TOK_KIND_LT:
        fprintf(fp, "<");
        break;
    case TOK_KIND_GT:
        fprintf(fp, ">");
        break;
    case TOK_KIND_DOT:
        fprintf(fp, ".");
        break;
    case TOK_KIND_ID:
        fprintf(fp, "ID");
        break;
    case TOK_KIND_EOF:
        fprintf(fp, "EOF");
        break;
    default:
        fprintf(fp, "Kind(%d)", tok->kind);
        break;
    }

    fprintf(fp, " ");
    token_fprint_buf(fp, tok);
    fprintf(fp, " (%ld, %ld)", tok->pos_begin, tok->pos_end);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edx
cmpl $0xb, %edx
jg 0x1bc3
cmpl $0x1, %edx
je 0x1be0
cmpl $0x2, %edx
je 0x1c01
cmpl $0x3, %edx
jne 0x1bee
movl $0x3e, %edi
jmp 0x1c06
cmpl $0xc, %edx
je 0x1be7
cmpl $0x18, %edx
je 0x1c10
cmpl $0x1f, %edx
jne 0x1bee
leaq 0x56e0(%rip), %rdi      # 0x72b9
movl $0x3, %esi
jmp 0x1c1c
movl $0x23, %edi
jmp 0x1c06
movl $0x2e, %edi
jmp 0x1c06
leaq 0x56a4(%rip), %rsi      # 0x7299
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1110
jmp 0x1c29
movl $0x3c, %edi
movq %rbx, %rsi
callq 0x10f0
jmp 0x1c29
leaq 0x567f(%rip), %rdi      # 0x7296
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11b0
movl $0x20, %edi
movq %rbx, %rsi
callq 0x10f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c61
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
leaq 0x5652(%rip), %rsi      # 0x72a2
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parser_new
Parser* parser_new(Vector* tokens, NodeArena* arena) {
    Parser* p = (Parser*)malloc(sizeof(Parser));
    if (!p) {
        return 0;
    }
    p->tokens = tokens;
    p->arena = arena;
    p->position = 0;
    p->position_stack = vector_new(sizeof(size_t));

    return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x1150
testq %rax, %rax
je 0x1cf8
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0x30b4
movq %rax, 0x18(%rbx)
jmp 0x1cfa
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parser_parse
ParserResult parser_parse(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_transition_unit(parser); ErrProp;

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r12
leaq 0xe4(%rip), %rdx        # 0x1e1f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1ea0
cmpl $0x1, (%r15)
jne 0x1d54
movq %r12, 0x10(%r14)
jmp 0x1d71
movq 0x20(%rsp), %r15
movq 0x8(%r14), %rdi
callq 0x3876
movl $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x20(%rsp)
movups 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rbx)
movups %xmm0, (%rbx)
cmpl $0x1, (%rbx)
jne 0x1d94
movq %r12, 0x10(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parser_fprint_error
void parser_fprint_error(FILE *fp, ParseError *err) {
    switch (err->kind) {
    case PARSER_ERROR_KIND_EOF:
        fprintf(fp, "Unexpected EOF");
        break;

    case PARSER_ERROR_KIND_UNEXPECTED:
        fprintf(fp, "Unexpected token: ");
        token_fprint(fp, err->value.unexpected.token);
        break;

    case PARSER_ERROR_KIND_MORE1:
        fprintf(fp, "Eexpected more than 0 tokens");
        break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x2, %eax
je 0x1df7
cmpl $0x1, %eax
je 0x1dc8
testl %eax, %eax
jne 0x1e17
leaq 0x54ed(%rip), %rdi      # 0x72ae
movl $0xe, %esi
jmp 0x1e03
movq %rsi, %r14
leaq 0x54eb(%rip), %rdi      # 0x72bd
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11b0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b9c
leaq 0x54d2(%rip), %rdi      # 0x72d0
movl $0x1c, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: combinator_more1_sep
ParserResult combinator_more1_sep(Parser *parser, TokenKind sep, ParserResult (*f)(Parser *parser)) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    Vector* elems = vector_new(sizeof(Node*));

    for(;;) {
        res = f(parser);
        if (res.result == PARSER_ERROR) {
            break;
        }

        Node** np = (Node**)vector_append(elems);
        *np = res.value.node;
    }

    if (vector_len(elems) == 0) {
        vector_drop(elems);

        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_MORE1;

        rewind_state(parser, _parser_state);
        return res;
    }

    res.result = PARSER_OK;
    res.value.nodes = elems;

    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rbp
movl $0x8, %edi
callq 0x30b4
movq %rax, %r15
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq *%r12
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x1, (%rbx)
je 0x1f1f
leaq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0x31d0
movq 0x18(%rbx), %rcx
movq %rcx, (%rax)
movq %r13, %rdi
movq %r14, %rsi
callq *%r12
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0x1, (%rbx)
jne 0x1ef1
movq %r15, %rdi
callq 0x322b
testq %rax, %rax
je 0x1f38
movl $0x0, (%rbx)
movq %r15, 0x18(%rbx)
jmp 0x1f51
movq %r15, %rdi
callq 0x31af
movl $0x1, (%rbx)
movl $0x2, 0x8(%rbx)
movq %rbp, 0x10(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parse_id
ParserResult parse_id(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = current_token(parser); ErrProp;
    forward_token(parser);

    debug_print_current_token(parser);

    Token* t = res.value.token;
    switch (t->kind) {
    case TOK_KIND_ID:
    {
        Node* node = node_arena_malloc(parser->arena);
        node->kind = NODE_ID;
        node->value.id.tok = t;

        res.result = PARSER_OK;
        res.value.node = node;

        return res;
    }

    default:
        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_UNEXPECTED;
        res.error.value.unexpected.token = t;

        rewind_state(parser, _parser_state);
        return res;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x10(%rsi), %r15
movq %r15, %rsi
callq 0x3216
movq %rax, %r12
xorl %eax, %eax
testq %r12, %r12
sete %al
movl %eax, (%rbx)
movl $0x0, 0x8(%rbx)
movq %r12, 0x18(%rbx)
je 0x1fda
incq 0x10(%r14)
movq %r14, %rdi
callq 0x2460
cmpl $0x18, (%r12)
jne 0x1fcc
movq 0x8(%r14), %rdi
callq 0x3876
movl $0xa, (%rax)
movq %r12, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, 0x18(%rbx)
jmp 0x1fde
movl $0x1, %eax
movl %eax, (%rbx)
movl %eax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parse_stmt_compound
ParserResult parse_stmt_compound(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = assume_token(parser, TOK_KIND_LBRACE); ErrProp;
    forward_token(parser);

    res = combinator_more1(parser, parse_block_item); ErrProp;
    Vector* nodes = res.value.nodes;

    res = assume_token(parser, TOK_KIND_RBRACE); ErrProp;
    forward_token(parser);

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_STMT_COMPOUND;
    node->value.stmt_compound.stmts = nodes;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x10(%rsi), %r15
movq %r15, %rsi
callq 0x3216
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
je 0x23bd
xorl %edx, %edx
cmpl $0x8, (%rax)
setne %dl
movl $0x1, %esi
cmovnel %esi, %ecx
jmp 0x23bf
xorl %edx, %edx
movl %ecx, (%rbx)
movl %edx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
testl %ecx, %ecx
jne 0x242a
incq 0x10(%r14)
leaq 0x1dd(%rip), %rdx       # 0x25b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ea0
cmpl $0x1, (%rbx)
je 0x242a
movq 0x18(%rbx), %r12
movq (%r14), %rdi
movq 0x10(%r14), %rsi
callq 0x3216
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
je 0x2417
xorl %edx, %edx
cmpl $0x9, (%rax)
setne %dl
movl $0x1, %esi
cmovnel %esi, %ecx
jmp 0x2419
xorl %edx, %edx
movl %ecx, (%rbx)
movl %edx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
testl %ecx, %ecx
je 0x243d
movq %r15, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
incq 0x10(%r14)
movq 0x8(%r14), %rdi
callq 0x3876
movl $0x2, (%rax)
movq %r12, 0x8(%rax)
movl $0x0, (%rbx)
movq %rax, 0x18(%rbx)
jmp 0x242e
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: debug_print_current_token
void debug_print_current_token(Parser *parser) {
    fprintf(DEBUGOUT, "DEBUG_PRINT: CURRENT_TOKEN ");

    ParserResult res = current_token(parser);
    if (res.result == PARSER_ERROR) {
        fprintf(DEBUGOUT, "ERR!\n");
        return;
    }

    fprintf(DEBUGOUT, "OK! -> ");
    token_fprint_buf(DEBUGOUT, res.value.token);
    fprintf(DEBUGOUT, "\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8b6a(%rip), %r14      # 0xafd8
movq (%r14), %rcx
leaq 0x4e75(%rip), %rdi      # 0x72ed
movl $0x1b, %esi
movl $0x1, %edx
callq 0x11b0
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3216
movq (%r14), %rcx
testq %rax, %rax
je 0x24d3
movq %rax, %rbx
leaq 0x4e6a(%rip), %rdi      # 0x730f
movl $0x7, %esi
movl $0x1, %edx
callq 0x11b0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1c61
movq (%r14), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10f0
leaq 0x4e2f(%rip), %rdi      # 0x7309
movl $0x5, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: assume_token
ParserResult assume_token(Parser *parser, TokenKind kind) {
    ParserResult res = current_token(parser);
    if (res.result == PARSER_ERROR) {
        return res;
    }

    Token* t = res.value.token;

    if (t->kind != kind) {
        res.result = PARSER_ERROR;
        res.error.kind = PARSER_ERROR_KIND_UNEXPECTED;
        res.error.value.unexpected.token = t;

        // This function does not consume any tokens, not rewind

        return res;
    }

    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x10(%rsi), %rsi
callq 0x3216
testq %rax, %rax
je 0x2515
movl $0x0, (%rbx)
movq %rax, 0x18(%rbx)
jmp 0x2522
movl $0x1, (%rbx)
movl $0x0, 0x8(%rbx)
cmpl $0x1, (%rbx)
je 0x253d
movq 0x18(%rbx), %rax
cmpl %ebp, (%rax)
je 0x253d
movl $0x1, %ecx
movl %ecx, (%rbx)
movl %ecx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parse_parameter_declaration
ParserResult parse_parameter_declaration(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_declaration_specifiers(parser); ErrProp;
    Node* spec = res.value.node;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_PARAM_DECL;
    node->value.param_decl.spec = spec;

    res = parse_declarator(parser);
    if (res.result == PARSER_ERROR) {
        goto next_phase;
    }
    node->value.param_decl.decl = res.value.node;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;

next_phase:
    // TODO: support 'abstract-declarator opt'
    node->value.param_decl.decl = NULL;

    res.result = PARSER_OK;
    res.value.node = node;

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
callq 0x1f63
cmpl $0x1, (%rbx)
jne 0x2569
movq %r15, 0x10(%r14)
jmp 0x25a9
movq 0x18(%rbx), %r12
movq 0x8(%r14), %rdi
callq 0x3876
movq %rax, %r15
movl $0xe, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fed
cmpl $0x1, (%rbx)
je 0x2599
movq 0x18(%rbx), %rax
jmp 0x259b
xorl %eax, %eax
movq %rax, 0x10(%r15)
movl $0x0, (%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/parser.c
// Function: parse_expr_additive
ParserResult parse_expr_additive(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_expr_postfix(parser); ErrProp;

    for (;;) {
        _parser_state = save_state(parser);

        ParserResult res0 = current_token(parser);
        if (res0.result == PARSER_ERROR) {
            rewind_state(parser, _parser_state);
            goto escape;
        }
        Token* op = res0.value.token;

        switch (op->kind) {
        case TOK_KIND_PLUS:
            break;
        case TOK_KIND_MINUS:
            break;
        default:
            rewind_state(parser, _parser_state);
            goto escape;
        }
        forward_token(parser);

        res0 = parse_expr_postfix(parser);
        if (res0.result == PARSER_ERROR) {
            rewind_state(parser, _parser_state);
            goto escape;
        }

        Node* node = node_arena_malloc(parser->arena);
        node->kind = NODE_EXPR_BIN;
        node->value.expr_bin.op = op;
        node->value.expr_bin.lhs = res.value.node;
        node->value.expr_bin.rhs = res0.value.node;

        res.value.node = node;

        _parser_state = save_state(parser); // Forward state
    }

escape:
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
callq 0x2b85
cmpl $0x1, (%rbx)
je 0x2b6f
movq 0x10(%r14), %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3216
testq %rax, %rax
je 0x2aba
movl $0x0, 0x8(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x2aca
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x1, 0x8(%rsp)
je 0x2b6f
movq 0x18(%rbx), %rbp
movq 0x20(%rsp), %r12
movl (%r12), %eax
andl $-0x2, %eax
cmpl $0xe, %eax
jne 0x2b68
incq 0x10(%r14)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2b85
cmpl $0x1, 0x8(%rsp)
je 0x2b68
movq 0x8(%r14), %rdi
callq 0x3876
movq %rax, %r13
movl $0x6, (%rax)
movq %r12, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%r13)
movq 0x10(%r14), %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3216
testq %rax, %rax
je 0x2b48
movl $0x0, 0x8(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x2b58
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x1, 0x8(%rsp)
movq %r13, %rbp
jne 0x2ad9
jmp 0x2b6b
movq %rbp, %r13
movq %r13, 0x18(%rbx)
movq %r15, 0x10(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/arena.c
// Function: arena_new
Arena* arena_new(size_t elem_size, void (*dtor)(void*)) {
    Arena* v = (Arena*)malloc(sizeof(Arena));
    if (!v) {
        return 0;
    }
    v->current = vector_new_with_cap(elem_size, 128);
    v->chain = vector_new(sizeof(Vector*));
    v->elem_size = elem_size;
    v->dtor = dtor;

    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x1150
testq %rax, %rax
je 0x2f79
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
callq 0x30df
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x30b4
movq %rax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
jmp 0x2f7b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/arena.c
// Function: arena_malloc
void* arena_malloc(Arena *arena) {
    if (vector_len(arena->current) == vector_cap(arena->current)) {
        // Move an ownership of current into chain
        Vector** c = (Vector**)vector_append(arena->chain);
        (*c) = arena->current;

        // Allocate a new space
        arena->current = vector_new_with_cap(arena->elem_size, vector_cap(arena->current) * 2);

        return arena_malloc(arena);
    }

    return vector_append(arena->current);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x322b
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3230
cmpq %rax, %r14
jne 0x2fcf
movq 0x8(%rbx), %rdi
callq 0x31d0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x3230
leaq (%rax,%rax), %rsi
movq %r14, %rdi
callq 0x30df
movq %rax, (%rbx)
jmp 0x2f8b
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31d0
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/arena.c
// Function: arena_drop
void arena_drop(Arena *arena) {
    if (!arena) {
        return;
    }

    for(size_t i=0; i<vector_len(arena->current); ++i) {
        void* e = vector_at(arena->current, i);
        arena->dtor(e);
    }
    vector_drop(arena->current);

    for(size_t i=0; i<vector_len(arena->chain); ++i) {
        Vector** c = (Vector**)vector_at(arena->chain, i);
        for(size_t j=0; j<vector_len(*c); ++j) {
            void* e = vector_at(*c, j);
            arena->dtor(e);
        }
        vector_drop(*c);
    }
    vector_drop(arena->chain);

    free(arena);
}

// Assembly:
testq %rdi, %rdi
je 0x30b1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x322b
testq %rax, %rax
je 0x3023
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3216
movq %rax, %rdi
callq *0x18(%rbx)
incq %r14
movq (%rbx), %rdi
callq 0x322b
cmpq %rax, %r14
jb 0x3002
movq (%rbx), %rdi
callq 0x31af
movq 0x8(%rbx), %rdi
callq 0x322b
testq %rax, %rax
je 0x3095
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3216
movq %rax, %r15
movq (%rax), %rdi
callq 0x322b
testq %rax, %rax
je 0x307c
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r12, %rsi
callq 0x3216
movq %rax, %rdi
callq *0x18(%rbx)
incq %r12
movq (%r15), %rdi
callq 0x322b
cmpq %rax, %r12
jb 0x305b
movq (%r15), %rdi
callq 0x31af
incq %r14
movq 0x8(%rbx), %rdi
callq 0x322b
cmpq %rax, %r14
jb 0x303c
movq 0x8(%rbx), %rdi
callq 0x31af
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
retq
nop
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/vector.c
// Function: vector_new
Vector* vector_new(size_t elem_size) {
    Vector* v = (Vector*)malloc(sizeof(Vector));
    if (!v) {
        return 0;
    }
    v->elem_size = elem_size;
    v->len = 0;
    v->cap = 0;
    v->buffer = 0;

    return v;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x1150
testq %rax, %rax
je 0x30db
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
jmp 0x30dd
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/vector.c
// Function: vector_new_with_cap
Vector* vector_new_with_cap(size_t elem_size, size_t cap) {
    Vector* v = vector_new(elem_size);
    bool res = extend(v, cap);
    assert(res);

    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x1150
testq %rax, %rax
je 0x3110
movq %rax, %rbx
movq %r15, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
jmp 0x3112
xorl %ebx, %ebx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3149
testb %al, %al
je 0x312a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4264(%rip), %rdi      # 0x7395
leaq 0x4261(%rip), %rsi      # 0x7399
leaq 0x4263(%rip), %rcx      # 0x73a2
movl $0x20, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/vector.c
// Function: extend
static bool extend(Vector *v, size_t ext_size) {
    size_t new_cap = v->cap + ext_size;
    char* new_buffer = (char*)malloc(v->elem_size * new_cap);
    if (!new_buffer) {
        return false;
    }

    if (v->buffer) {
        memcpy(new_buffer, v->buffer, v->elem_size * v->len);
        free(v->buffer);
    }

    v->cap = new_cap;
    v->buffer = new_buffer;

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq 0x10(%rdi), %rbx
movq (%rdi), %r12
movq %r12, %rdi
imulq %rbx, %rdi
callq 0x1150
movq %rax, %r15
testq %rax, %rax
je 0x319f
movq 0x18(%r14), %r13
testq %r13, %r13
je 0x3197
imulq 0x8(%r14), %r12
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1140
movq %r13, %rdi
callq 0x1040
movq %rbx, 0x10(%r14)
movq %r15, 0x18(%r14)
testq %r15, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/vector.c
// Function: vector_drop
void vector_drop(Vector *v) {
    if (!v) {
        return;
    }

    if (v->buffer) {
        free(v->buffer);
    }

    free(v);
}

// Assembly:
testq %rdi, %rdi
je 0x31cf
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x31c6
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/vector.c
// Function: vector_append
void* vector_append(Vector *v) {
    if (v->len == v->cap) {
        size_t ext_size = v->cap == 0 ? 24 : v->cap * 2; //
        if (!extend(v, ext_size)) {
            return 0;
        }
    }

    // TODO: Consider alignment
    char* p = &v->buffer[v->elem_size * v->len];
    v->len++;

    return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jne 0x31fa
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x18, %esi
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0x3149
testb %al, %al
je 0x3212
movq 0x8(%rbx), %rcx
movq (%rbx), %rax
imulq %rcx, %rax
addq 0x18(%rbx), %rax
incq %rcx
movq %rcx, 0x8(%rbx)
jmp 0x3214
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/node.c
// Function: node_declarator_extract_id_token
Token* node_declarator_extract_id_token(Node* node) {
    switch(node->kind) {
    case NODE_DECLARATOR:
        return node_declarator_extract_id_token(node->value.declarator.node);
    case NODE_DIRECT_DECLARATOR:
        return node_declarator_extract_id_token(node->value.direct_declarator.base);
    case NODE_ID:
        return node->value.id.tok;
    default:
        return NULL;
    }
}

// Assembly:
movl (%rdi), %eax
cmpl $0xc, %eax
je 0x384c
cmpl $0xd, %eax
jne 0x3852
movq 0x10(%rdi), %rdi
jmp 0x383a
movq 0x8(%rdi), %rdi
jmp 0x383a
cmpl $0xa, %eax
jne 0x385c
movq 0x8(%rdi), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/ir.c
// Function: ir_function_set_local
void ir_function_set_local(IRFunction* f, IRSymbolID id, size_t size) {
    while(vector_len(f->locals) <= id) {
        void* e = vector_append(f->locals);
        assert(e);
    }

    size_t* s = vector_at(f->locals, id);
    *s = size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%r15), %rdi
callq 0x322b
movq 0x28(%r15), %rdi
cmpq %r14, %rax
ja 0x38c5
callq 0x31d0
testq %rax, %rax
jne 0x388a
leaq 0x37a3(%rip), %rdi      # 0x7050
leaq 0x3c0c(%rip), %rsi      # 0x74c0
leaq 0x3c0a(%rip), %rcx      # 0x74c5
movl $0x2b, %edx
callq 0x10d0
movq %r14, %rsi
callq 0x3216
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/ir.c
// Function: ir_module_new
IRModule* ir_module_new() {
    IRModule* m = (IRModule*)malloc(sizeof(IRModule));
    m->definitions = vector_new(sizeof(IRInst));
    m->functions = vector_new(sizeof(IRFunction));
    m->defs_sym_id = 0;

    return m;
}

// Assembly:
pushq %rbx
movl $0x18, %edi
callq 0x1150
movq %rax, %rbx
movl $0x30, %edi
callq 0x30b4
movq %rax, (%rbx)
movl $0x38, %edi
callq 0x30b4
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/ir.c
// Function: ir_module_drop
void ir_module_drop(IRModule *m) {
    for(size_t i=0; i<vector_len(m->definitions); ++i) {
        IRInst* inst = vector_at(m->definitions, i);
        ir_inst_destruct(inst);
    }
    vector_drop(m->definitions);

    for(size_t i=0; i<vector_len(m->functions); ++i) {
        IRFunction* f = vector_at(m->functions, i);
        ir_function_destruct(f);
    }
    vector_drop(m->functions);

    free(m);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x322b
testq %rax, %rax
je 0x3956
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3216
movq %rax, %rdi
callq 0x6062
incq %r14
movq (%rbx), %rdi
callq 0x322b
cmpq %rax, %r14
jb 0x3933
movq (%rbx), %rdi
callq 0x31af
movq 0x8(%rbx), %rdi
callq 0x322b
testq %rax, %rax
je 0x39a9
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3216
movq %rax, %r15
movq (%rax), %rdi
callq 0x1040
movq 0x10(%r15), %rdi
callq 0x6039
movq 0x28(%r15), %rdi
callq 0x31af
incq %r14
movq 0x8(%rbx), %rdi
callq 0x322b
cmpq %rax, %r14
jb 0x396f
movq 0x8(%rbx), %rdi
callq 0x31af
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/ir.c
// Function: ir_builder_new
IRBuilder* ir_builder_new() {
    IRBuilder* builder = (IRBuilder*)malloc(sizeof(IRBuilder));
    builder->current_func = NULL;
    builder->current_bb = NULL;

    return builder;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x1150
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/yutopp[P]cc/ir.c
// Function: ir_module_fprint
void ir_module_fprint(FILE* fp, IRModule* m) {
    for(size_t i=0; i<vector_len(m->definitions); ++i) {
        IRInst* inst = vector_at(m->definitions, i);
        ir_inst_fprint(fp, inst);
    }

    for(size_t i=0; i<vector_len(m->functions); ++i) {
        IRFunction* f = vector_at(m->functions, i);
        ir_function_fprint(fp, f);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x322b
testq %rax, %rax
je 0x3bad
xorl %r15d, %r15d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3216
movq %r14, %rdi
movq %rax, %rsi
callq 0x3c1a
incq %r15
movq (%rbx), %rdi
callq 0x322b
cmpq %rax, %r15
jb 0x3b87
movq 0x8(%rbx), %rdi
callq 0x322b
testq %rax, %rax
je 0x3c0b
leaq 0x3940(%rip), %r15      # 0x7502
leaq 0x2ae(%rip), %r12       # 0x3e77
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
movq %r13, %rsi
callq 0x3216
movq %rax, %rbp
movq (%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1110
movq 0x18(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5f1b
incq %r13
movq 0x8(%rbx), %rdi
callq 0x322b
cmpq %rax, %r13
jb 0x3bcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq