LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/settings.c
// Function: read_config_file
void
read_config_file(const char *path)
{
	FILE *fp = NULL;

	log_assert_arg_nonnull("read_config_file", "path", path);

	if (g_conf_read) {
		return;
	} else if (!is_regularFile(path)) {
		fatal(0, "%s: either the config file is nonexistent"
		    "  --  or it isn't a regular file", __func__);
	} else if ((fp = fopen(path, "r")) == NULL) {
		fatal(errno, "%s: fopen", __func__);
	}

	Interpreter_processAllLines(fp, path, is_recognized_setting,
	    install_setting);

	if (feof(fp))
		fclose(fp);
	else if (ferror(fp))
		fatal(0, "%s: %s", __func__, g_fgets_nullret_err1);
	else
		fatal(0, "%s: %s", __func__, g_fgets_nullret_err2);

	g_conf_read = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x3283(%rip), %rdi      # 0xcad2
leaq 0x31cf(%rip), %rsi      # 0xca25
callq 0x8ea0
testb $0x1, 0x719e(%rip)      # 0x10a00
je 0x9869
jmp 0x994c
movq -0x8(%rbp), %rdi
callq 0xa1b0
testb $0x1, %al
jne 0x988d
xorl %edi, %edi
leaq 0x3264(%rip), %rsi      # 0xcae3
leaq 0x324c(%rip), %rdx      # 0xcad2
movb $0x0, %al
callq 0x5fa0
movq -0x8(%rbp), %rdi
leaq 0x233f(%rip), %rsi      # 0xbbd7
callq 0x4500
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x98c3
callq 0x4050
movl (%rax), %edi
leaq 0x3278(%rip), %rsi      # 0xcb2d
leaq 0x3216(%rip), %rdx      # 0xcad2
movb $0x0, %al
callq 0x5fa0
jmp 0x98c5
jmp 0x98c7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x8a(%rip), %rdx        # 0x9960
leaq 0x103(%rip), %rcx       # 0x99e0
callq 0x5da0
movq -0x10(%rbp), %rdi
callq 0x46c0
cmpl $0x0, %eax
je 0x98fb
movq -0x10(%rbp), %rdi
callq 0x4400
jmp 0x9945
movq -0x10(%rbp), %rdi
callq 0x4790
cmpl $0x0, %eax
je 0x9927
xorl %edi, %edi
leaq 0x296c(%rip), %rsi      # 0xc27e
leaq 0x31b9(%rip), %rdx      # 0xcad2
leaq 0x1970(%rip), %rcx      # 0xb290
movb $0x0, %al
callq 0x5fa0
xorl %edi, %edi
leaq 0x294e(%rip), %rsi      # 0xc27e
leaq 0x319b(%rip), %rdx      # 0xcad2
leaq 0x19a2(%rip), %rcx      # 0xb2e0
movb $0x0, %al
callq 0x5fa0
movb $0x1, 0x70b4(%rip)      # 0x10a00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/settings.c
// Function: is_recognized_setting
static bool
is_recognized_setting(const char *setting_name)
{
	if (setting_name == NULL)
		return false;
	FOREACH_CDV() {
		if (strings_match(setting_name, cdv->setting_name))
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9979
movb $0x0, -0x1(%rbp)
jmp 0x99c7
leaq 0x6b30(%rip), %rax      # 0x104b0
movq %rax, -0x18(%rbp)
leaq 0x6b25(%rip), %rax      # 0x104b0
addq $0x190, %rax            # imm = 0x190
cmpq %rax, -0x18(%rbp)
jae 0x99c3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x8c20
testb $0x1, %al
jne 0x99ad
jmp 0x99b3
movb $0x1, -0x1(%rbp)
jmp 0x99c7
jmp 0x99b5
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x9984
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x99fe
cmpq $0x0, -0x18(%rbp)
jne 0x9a0a
movl $0x16, -0x4(%rbp)
jmp 0x9aa6
leaq 0x6a9f(%rip), %rax      # 0x104b0
movq %rax, -0x20(%rbp)
leaq 0x6a94(%rip), %rax      # 0x104b0
addq $0x190, %rax            # imm = 0x190
cmpq %rax, -0x20(%rbp)
jae 0x9a9f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x8c20
testb $0x1, %al
jne 0x9a3e
jmp 0x9a8c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x9a52
movl $0x10, -0x4(%rbp)
jmp 0x9aa6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x8f20
testb $0x1, %al
jne 0x9a6f
movl $0x16, -0x4(%rbp)
jmp 0x9aa6
movq -0x18(%rbp), %rdi
callq 0xa610
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9aa6
jmp 0x9a8e
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
jmp 0x9a15
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x80(%rbp), %rdi
callq 0x4540
leaq 0x6b75(%rip), %rax      # 0x10640
movq %rax, -0x88(%rbp)
leaq 0x6b67(%rip), %rax      # 0x10640
addq $0x1c0, %rax            # imm = 0x1C0
cmpq %rax, -0x88(%rbp)
jae 0x9b1d
movq -0x88(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x9b07
movq -0x88(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x4690
jmp 0x9b09
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x88(%rbp)
jmp 0x9ad2
xorl %edi, %edi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x41d0
cmpl $0x0, %eax
je 0x9b4d
callq 0x4050
movl (%rax), %edi
leaq 0x3573(%rip), %rsi      # 0xd0b2
leaq 0x3580(%rip), %rdx      # 0xd0c6
movb $0x0, %al
callq 0x5fa0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0x8a90
callq 0x97d0
leaq 0x6e8b(%rip), %rax      # 0x10a00
testb $0x1, (%rax)
je 0x9b96
leaq 0x3553(%rip), %rdi      # 0xd0d4
leaq 0x1a38(%rip), %rsi      # 0xb5c0
leaq 0x1a3e(%rip), %rdx      # 0xb5cd
movb $0x0, %al
callq 0x6260
leaq 0x6873(%rip), %rax      # 0x10410
cmpl $-0x1, (%rax)
je 0x9bb0
leaq 0x6867(%rip), %rax      # 0x10410
movl (%rax), %edi
callq 0x47e0
leaq 0x6d6a(%rip), %rax      # 0x10921
testb $0x1, (%rax)
je 0x9bc1
callq 0x43e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x4210
leaq -0x88(%rbp), %rdi
callq 0x4130
leaq -0x120(%rbp), %rdi
addq $0x8, %rdi
callq 0x4130
movl $0x0, -0x98(%rbp)
movl $0x2, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x41d0
cmpl $0x0, %eax
je 0x9c56
callq 0x4050
movl (%rax), %edi
leaq 0x34a9(%rip), %rsi      # 0xd0e5
leaq 0x34b2(%rip), %rdx      # 0xd0f5
movb $0x0, %al
callq 0x6300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d69
leaq 0x69e3(%rip), %rax      # 0x10640
movq %rax, -0x128(%rbp)
leaq 0x69d5(%rip), %rax      # 0x10640
addq $0x1c0, %rax            # imm = 0x1C0
cmpq %rax, -0x128(%rbp)
jae 0x9d17
movq -0x128(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x9c99
movl $0x1, %eax
movq %rax, -0x120(%rbp)
jmp 0x9ca7
leaq 0xe0(%rip), %rax        # 0x9d80
movq %rax, -0x120(%rbp)
movq -0x128(%rbp), %rax
movl (%rax), %edi
leaq -0x120(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4550
cmpl $0x0, %eax
je 0x9cfe
callq 0x4050
movl (%rax), %edi
movq -0x128(%rbp), %rax
movl (%rax), %ecx
movq -0x128(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x341b(%rip), %rsi      # 0xd102
leaq 0x3407(%rip), %rdx      # 0xd0f5
movb $0x0, %al
callq 0x6300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d69
jmp 0x9d00
movq -0x128(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x128(%rbp)
jmp 0x9c64
leaq -0x88(%rbp), %rdi
callq 0x4540
movl $0x2, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x41d0
cmpl $0x0, %eax
je 0x9d62
callq 0x4050
movl (%rax), %edi
leaq 0x339a(%rip), %rsi      # 0xd0e5
leaq 0x33a3(%rip), %rdx      # 0xd0f5
movb $0x0, %al
callq 0x6300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9d69
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x9b60
leaq 0x68a9(%rip), %rax      # 0x10640
movq %rax, -0x10(%rbp)
leaq 0x689e(%rip), %rax      # 0x10640
addq $0x1c0, %rax            # imm = 0x1C0
cmpq %rax, -0x10(%rbp)
jae 0x9def
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x9ddf
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
xorl %edi, %edi
leaq 0x34f9(%rip), %rsi      # 0xd2d1
movb $0x0, %al
callq 0x6300
jmp 0x9de1
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
jmp 0x9d9b
movl $0x1, %edi
callq 0x4700
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/various.c
// Function: is_directory
bool
is_directory(const char *path)
{
	struct stat sb = { 0 };

	if (path == NULL || *path == '\0')
		return false;
	return (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x4210
cmpq $0x0, -0x10(%rbp)
je 0xa0d5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa0db
movb $0x0, -0x1(%rbp)
jmp 0xa11e
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x43b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa1(%rbp)
jne 0xa113
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa14f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa155
movb $0x0, -0x1(%rbp)
jmp 0xa1a3
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa19f
callq 0x4460
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xa18f
movb $0x0, -0x1(%rbp)
jmp 0xa1a3
jmp 0xa191
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa15d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/various.c
// Function: is_regularFile
bool
is_regularFile(const char *path)
{
	struct stat sb = { 0 };

	if (path == NULL || *path == '\0')
		return false;
	return (stat(path, &sb) == 0 && S_ISREG(sb.st_mode));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x4210
cmpq $0x0, -0x10(%rbp)
je 0xa1e5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa1eb
movb $0x0, -0x1(%rbp)
jmp 0xa22e
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x43b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa1(%rbp)
jne 0xa223
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa26e
movl $0x16, %edi
leaq 0x309b(%rip), %rsi      # 0xd302
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa284
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2f8
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, -0x18(%rbp)
jmp 0xa293
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0xa2f0
callq 0x4460
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xa2e0
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x4660
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0xa2e2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa29b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa336
movl $0x16, %edi
leaq 0x2fde(%rip), %rsi      # 0xd30d
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa34c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa3c0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jb 0xa3ae
callq 0x4460
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xa39e
jmp 0xa3ae
jmp 0xa3a0
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa36f
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0xa3b8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x4210
callq 0x4050
movl $0x0, (%rax)
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x44b0
cmpl $0x0, %eax
je 0xa472
callq 0x4050
movl (%rax), %edi
leaq 0x2ee1(%rip), %rsi      # 0xd345
leaq 0x2ee8(%rip), %rdx      # 0xd353
movb $0x0, %al
callq 0x5fa0
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0xa48b
jmp 0xa47e
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0xa4d1
jmp 0xa517
movl -0x34(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xa4cf
movl -0x34(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x34(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x4570
cmpl $0x0, %eax
je 0xa4cd
callq 0x4050
movl (%rax), %edi
leaq 0x2ea0(%rip), %rsi      # 0xd35f
leaq 0x2e8d(%rip), %rdx      # 0xd353
movb $0x0, %al
callq 0x5fa0
jmp 0xa4cf
jmp 0xa52e
movl -0x34(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xa515
movl -0x34(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x34(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x4570
cmpl $0x0, %eax
je 0xa513
callq 0x4050
movl (%rax), %edi
leaq 0x2e5a(%rip), %rsi      # 0xd35f
leaq 0x2e47(%rip), %rdx      # 0xd353
movb $0x0, %al
callq 0x5fa0
jmp 0xa515
jmp 0xa52e
xorl %edi, %edi
leaq 0x2e4d(%rip), %rsi      # 0xd36d
leaq 0x2e2c(%rip), %rdx      # 0xd353
movb $0x0, %al
callq 0x5fa0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xa578
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x7380
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x14(%rbp)
jge 0xa5f6
callq 0x4050
movl (%rax), %edi
leaq 0x2da1(%rip), %rsi      # 0xd390
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa64d
movl $0x16, %edi
leaq 0x2d5f(%rip), %rsi      # 0xd39e
leaq 0x2d6d(%rip), %rdx      # 0xd3b3
movb $0x0, %al
callq 0x5fa0
movq -0x8(%rbp), %rdi
callq 0x41b0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa68f
movq -0x18(%rbp), %rcx
movl $0xc, %edi
leaq 0x2d3a(%rip), %rsi      # 0xd3bb
leaq 0x2d2b(%rip), %rdx      # 0xd3b3
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9f30
cmpq -0x18(%rbp), %rax
jb 0xa6c0
movl $0x4b, %edi
leaq 0x2d28(%rip), %rsi      # 0xd3da
leaq 0x2cfa(%rip), %rdx      # 0xd3b3
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa702
movl $0x16, %edi
leaq 0x2ced(%rip), %rsi      # 0xd3e8
movb $0x0, %al
callq 0x5fa0
cmpq $0x0, -0x10(%rbp)
jne 0xa71c
movl $0x16, %edi
leaq 0x2d04(%rip), %rsi      # 0xd419
movb $0x0, %al
callq 0x5fa0
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x8(%rbp)
cmpq -0x10(%rbp), %rax
jae 0xa741
xorl %edi, %edi
leaq 0x2d0f(%rip), %rsi      # 0xd449
movb $0x0, %al
callq 0x5fa0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa774
movq -0x8(%rbp), %rdx
imulq -0x10(%rbp), %rdx
movl $0xc, %edi
leaq 0x2cf6(%rip), %rsi      # 0xd463
movb $0x0, %al
callq 0x5fa0
jmp 0xa776
jmp 0xa778
jmp 0xa77a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa7be
movl $0x16, %edi
leaq 0x2cda(%rip), %rsi      # 0xd491
movb $0x0, %al
callq 0x5fa0
movq -0x8(%rbp), %rdi
callq 0x45b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa7e8
movq -0x8(%rbp), %rdx
movl $0xc, %edi
leaq 0x2cd7(%rip), %rsi      # 0xd4b8
movb $0x0, %al
callq 0x5fa0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa832
movl $0x16, %edi
leaq 0x2cb1(%rip), %rsi      # 0xd4dc
movb $0x0, %al
callq 0x5fa0
cmpq $0x0, -0x10(%rbp)
jne 0xa84c
movl $0x16, %edi
leaq 0x2ccd(%rip), %rsi      # 0xd512
movb $0x0, %al
callq 0x5fa0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4720
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa87c
callq 0x4050
movl (%rax), %edi
movq -0x10(%rbp), %rdx
leaq 0x2cd1(%rip), %rsi      # 0xd546
movb $0x0, %al
callq 0x5fa0
jmp 0xa87e
jmp 0xa880
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/main.c
// Function: read_all
static char* read_all(FILE* fp) {
    fseek(fp, 0, SEEK_END);
    size_t size = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char *fcontent = malloc(size+1);
    fread(fcontent, sizeof(char), size, fp);
    fcontent[size] = '\0';

    return fcontent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1140
movq -0x8(%rbp), %rdi
callq 0x10f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1140
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x1120
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1120
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/lexer.c
// Function: read_id
static Token read_id(Lexer* lex) {
    for(;;) {
        char c0 = current(lex);

        switch(c0) {
        case 'A' ... 'Z':
        case 'a' ... 'z':
        case '0' ... '9':
            skip(lex);
            continue;
        }

        Token tok = make_token(lex, TOK_KIND_ID);
        char const* buf = tok.buf_ref + tok.pos_begin;
        if (strncmp("else", buf, tok.pos_end - tok.pos_begin) == 0) {
            tok.kind = TOK_KIND_ELSE;
        } else if (strncmp("if", buf, tok.pos_end - tok.pos_begin) == 0) {
            tok.kind = TOK_KIND_IF;
        } else if (strncmp("return", buf, tok.pos_end - tok.pos_begin) == 0) {
            tok.kind = TOK_KIND_RETURN;
        }
        return tok;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1910
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x2c(%rbp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0x199f
jmp 0x1981
movl -0x2c(%rbp), %eax
addl $-0x41, %eax
subl $0x1a, %eax
jb 0x199b
jmp 0x198e
movl -0x2c(%rbp), %eax
addl $-0x61, %eax
subl $0x1a, %eax
jb 0x199d
jmp 0x19aa
jmp 0x199d
jmp 0x199f
movq -0x8(%rbp), %rdi
callq 0x1930
jmp 0x1964
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x18, %edx
callq 0x1b90
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
addq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
leaq 0x98ac(%rip), %rdi      # 0xb28b
callq 0x1050
cmpl $0x0, %eax
jne 0x19f5
movq -0x28(%rbp), %rax
movl $0x1b, (%rax)
jmp 0x1a51
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
leaq 0x9884(%rip), %rdi      # 0xb290
callq 0x1050
cmpl $0x0, %eax
jne 0x1a22
movq -0x28(%rbp), %rax
movl $0x1a, (%rax)
jmp 0x1a4f
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x18(%rax), %rdx
subq 0x10(%rax), %rdx
leaq 0x985a(%rip), %rdi      # 0xb293
callq 0x1050
cmpl $0x0, %eax
jne 0x1a4d
movq -0x28(%rbp), %rax
movl $0x19, (%rax)
jmp 0x1a4f
jmp 0x1a51
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/lexer.c
// Function: read_number_lit
static Token read_number_lit(Lexer* lex) {
    for(;;) {
        char c0 = current(lex);

        if (c0 >= '0' && c0 <= '9') {
            skip(lex);
            continue;
        }

        return make_token(lex, TOK_KIND_INT_LIT);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1910
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jl 0x1a9d
movsbl -0x9(%rbp), %eax
cmpl $0x39, %eax
jg 0x1a9d
movq -0x8(%rbp), %rdi
callq 0x1930
jmp 0x1a74
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1c, %edx
callq 0x1b90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/lexer.c
// Function: read_string_lit
static Token read_string_lit(Lexer* lex) {
    lex->begin_pos = lex->current_pos;

    for(;;) {
        char c0 = current(lex);
        switch(c0) {
        case '"':
        {
            Token tok = make_token(lex, TOK_KIND_STRING_LIT);
            skip(lex);
            return tok;
        }

        default:
            skip(lex);
            continue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1910
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
subb $0x22, %al
jne 0x1b1e
jmp 0x1af9
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1e, %edx
callq 0x1b90
movq -0x8(%rbp), %rdi
callq 0x1930
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x1930
jmp 0x1ae4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/lexer.c
// Function: read_char_lit
static Token read_char_lit(Lexer* lex) {
    for(;;) {
        char c0 = current(lex);
        switch(c0) {
        case '\'':
        {
            Token tok = make_token(lex, TOK_KIND_CHAR_LIT);
            skip(lex);
            return tok;
        }

        default:
            skip(lex);
            continue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1910
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
subb $0x27, %al
jne 0x1b7e
jmp 0x1b59
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1d, %edx
callq 0x1b90
movq -0x8(%rbp), %rdi
callq 0x1930
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x1930
jmp 0x1b44
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/lexer.c
// Function: make_token
Token make_token(Lexer* lex, TokenKind kind) {
    Token tok = {
        .kind = kind,
        .buf_ref = lex->buffer,
        .pos_begin = lex->begin_pos,
        .pos_end = lex->current_pos,
    };
    return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rdi)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rdi)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1120
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x1110
movq -0x18(%rbp), %rax
movq -0x10(%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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1e, %eax
ja 0x1cf3
movq -0x18(%rbp), %rax
leaq 0x962a(%rip), %rcx      # 0xb29c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x9692(%rip), %rsi      # 0xb318
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
leaq 0x9680(%rip), %rsi      # 0xb31a
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
leaq 0x966e(%rip), %rsi      # 0xb31c
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
leaq 0x965c(%rip), %rsi      # 0xb31e
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
leaq 0x964a(%rip), %rsi      # 0xb320
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
leaq 0x9659(%rip), %rsi      # 0xb343
movb $0x0, %al
callq 0x10e0
jmp 0x1d0b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x961f(%rip), %rsi      # 0xb323
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
leaq 0x9834(%rip), %rsi      # 0xb54a
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x95e7(%rip), %rsi      # 0xb32c
movb $0x0, %al
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x20, %edi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ddf
movq $0x0, -0x8(%rbp)
jmp 0x1e1f
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0x42c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parser_drop
void parser_drop(Parser *parser) {
    if (!parser) {
        return;
    }
    vector_drop(parser->position_stack);

    free(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1e45
jmp 0x1e5b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4440
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1f10
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x1ed5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x1ed7
jmp 0x1ed7
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_transition_unit
ParserResult parse_transition_unit(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

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

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_TRANS_UNIT;
    node->value.trans_unit.decls = nodes;

    res.value.node = node;

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
leaq 0x170(%rip), %rdx       # 0x20b0
callq 0x2080
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x1f7c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x1fbe
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movl $0x0, (%rcx)
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x2023
jmp 0x200f
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x2037
jmp 0x2019
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x205c
jmp 0x206e
movq -0x8(%rbp), %rdi
leaq 0x930a(%rip), %rsi      # 0xb338
movb $0x0, %al
callq 0x10e0
jmp 0x206e
movq -0x8(%rbp), %rdi
leaq 0x9305(%rip), %rsi      # 0xb347
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1c40
jmp 0x206e
movq -0x8(%rbp), %rdi
leaq 0x92f3(%rip), %rsi      # 0xb35a
movb $0x0, %al
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x20(%rbp)
movl $0x8, %edi
callq 0x42c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq *%rax
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x214e
jmp 0x216f
movq -0x28(%rbp), %rdi
callq 0x4480
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x18(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2116
movq -0x28(%rbp), %rdi
callq 0x4580
cmpq $0x0, %rax
jne 0x21a7
movq -0x28(%rbp), %rdi
callq 0x4440
movq -0x60(%rbp), %rax
movl $0x1, (%rax)
movl $0x2, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1fd0
jmp 0x21b9
movq -0x60(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_function_definition
ParserResult parse_function_definition(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_id(parser); ErrProp; // TODO: fix
    Node* decl_spec = res.value.node;

    res = parse_declarator(parser); ErrProp;
    Node* decl = res.value.node;

    res = parse_stmt_compound(parser); ErrProp;
    Node* block = res.value.node;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_FUNC_DEF;
    node->value.func_def.decl_spec = decl_spec;
    node->value.func_def.decl = decl;
    node->value.func_def.block = block;

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

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2390
movq -0x98(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x2244
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2371
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x24a0
movq -0x98(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x229d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2371
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2550
movq -0x98(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jne 0x22f3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2371
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq -0x90(%rbp), %rcx
movl $0x1, (%rcx)
movq -0x38(%rbp), %rdx
movq -0x90(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x60(%rbp), %rdx
movq -0x90(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x88(%rbp), %rdx
movq -0x90(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movl $0x0, (%rax)
movq -0x90(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x26e0
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x23f8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2487
movq -0x8(%rbp), %rdi
callq 0x2750
movq -0x8(%rbp), %rdi
callq 0x2770
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
subl $0x18, %eax
jne 0x2461
jmp 0x2423
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movl $0xa, (%rcx)
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x2487
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yutopp[P]cc/parser.c
// Function: parse_declarator
ParserResult parse_declarator(Parser *parser) {
    ParserResult res;
    state_t _parser_state = save_state(parser);

    res = parse_direct_declarator(parser); ErrProp;

    Node* node = node_arena_malloc(parser->arena);
    node->kind = NODE_DECLARATOR;
    node->value.declarator.node = res.value.node;

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

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2810
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
cmpl $0x1, (%rdi)
jne 0x2505
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fd0
jmp 0x2541
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e00
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movl $0xc, (%rcx)
movq 0x18(%rax), %rdx
movq -0x38(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movl $0x0, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)