LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./parse.h
// Function: parse
void parse(struct terminal_t *term, uint8_t *buf, int size)
{
	/*
		CTRL CHARS      : 0x00 ~ 0x1F
		ASCII(printable): 0x20 ~ 0x7E
		CTRL CHARS(DEL) : 0x7F
		UTF-8           : 0x80 ~ 0xFF
	*/
	uint8_t ch;

	for (int i = 0; i < size; i++) {
		ch = buf[i];
		if (term->esc.state == STATE_RESET) {
			/* interrupted by illegal byte */
			if (term->charset.following_byte > 0 && (ch < 0x80 || ch > 0xBF)) {
				addch(term, REPLACEMENT_CHAR);
				reset_charset(term);
			}

			if (ch <= 0x1F)
				control_character(term, ch);
			else if (ch <= 0x7F)
				addch(term, ch);
			else
				utf8_charset(term, ch);
		} else if (term->esc.state == STATE_ESC) {
			if (push_esc(term, ch))
				esc_sequence(term, ch);
		} else if (term->esc.state == STATE_CSI) {
			if (push_esc(term, ch))
				csi_sequence(term, ch);
		} else if (term->esc.state == STATE_OSC) {
			if (push_esc(term, ch))
				osc_sequence(term, ch);
		} else if (term->esc.state == STATE_DCS) {
			if (push_esc(term, ch))
				dcs_sequence(term, ch);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9614
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x7c(%rax)
jne 0x9549
movq -0x8(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jle 0x9505
movzbl -0x15(%rbp), %eax
cmpl $0x80, %eax
jl 0x94ee
movzbl -0x15(%rbp), %eax
cmpl $0xbf, %eax
jle 0x9505
movq -0x8(%rbp), %rdi
movl $0x3f, %esi
callq 0x4fb0
movq -0x8(%rbp), %rdi
callq 0x5380
movzbl -0x15(%rbp), %eax
cmpl $0x1f, %eax
jg 0x951d
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x8ca0
jmp 0x9544
movzbl -0x15(%rbp), %eax
cmpl $0x7f, %eax
jg 0x9535
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x4fb0
jmp 0x9542
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x9130
jmp 0x9544
jmp 0x9604
movq -0x8(%rbp), %rax
cmpl $0x1, 0x7c(%rax)
jne 0x9578
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x5170
testb $0x1, %al
jne 0x9566
jmp 0x9573
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x8d10
jmp 0x9602
movq -0x8(%rbp), %rax
cmpl $0x2, 0x7c(%rax)
jne 0x95a4
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x5170
testb $0x1, %al
jne 0x9595
jmp 0x95a2
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x8db0
jmp 0x9600
movq -0x8(%rbp), %rax
cmpl $0x4, 0x7c(%rax)
jne 0x95d0
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x5170
testb $0x1, %al
jne 0x95c1
jmp 0x95ce
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x8f10
jmp 0x95fe
movq -0x8(%rbp), %rax
cmpl $0x8, 0x7c(%rax)
jne 0x95fc
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x5170
testb $0x1, %al
jne 0x95ed
jmp 0x95fa
movq -0x8(%rbp), %rdi
movzbl -0x15(%rbp), %esi
callq 0x9010
jmp 0x95fc
jmp 0x95fe
jmp 0x9600
jmp 0x9602
jmp 0x9604
jmp 0x9606
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x94aa
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: sig_handler
void sig_handler(int signo)
{
	sigset_t sigset;
	/* global */
	extern volatile sig_atomic_t vt_active;
	extern volatile sig_atomic_t child_alive;
	extern volatile sig_atomic_t need_redraw;

	logging(DEBUG, "caught signal! no:%d\n", signo);

	if (signo == SIGCHLD) {
		child_alive = false;
		wait(NULL);
	} else if (signo == SIGUSR1) { /* vt activate */
		vt_active   = true;
		need_redraw = true;
		ioctl(STDIN_FILENO, VT_RELDISP, VT_ACKACQ);
	} else if (signo == SIGUSR2) { /* vt deactivate */
		vt_active = false;
		ioctl(STDIN_FILENO, VT_RELDISP, 1);

		if (BACKGROUND_DRAW) { /* update passive cursor */
			need_redraw = true;
		} else {               /* sleep until next vt switching */
			sigfillset(&sigset);
			sigdelset(&sigset, SIGUSR1);
			sigsuspend(&sigset);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
xorl %edi, %edi
leaq 0x4c954(%rip), %rsi     # 0x55f8e
movb $0x0, %al
callq 0x2450
cmpl $0x11, -0x4(%rbp)
jne 0x965c
movl $0x0, 0x505b7(%rip)     # 0x59c08
xorl %eax, %eax
movl %eax, %edi
callq 0x2300
jmp 0x96db
cmpl $0xa, -0x4(%rbp)
jne 0x968b
movl $0x1, 0x4fb54(%rip)     # 0x591c0
movl $0x1, 0x5058e(%rip)     # 0x59c04
xorl %edi, %edi
movl $0x5605, %esi           # imm = 0x5605
movl $0x2, %edx
movb $0x0, %al
callq 0x2130
jmp 0x96d9
cmpl $0xc, -0x4(%rbp)
jne 0x96d7
movl $0x0, 0x4fb25(%rip)     # 0x591c0
xorl %edi, %edi
movl $0x5605, %esi           # imm = 0x5605
movl $0x1, %edx
movb $0x0, %al
callq 0x2130
leaq -0x88(%rbp), %rdi
callq 0x21b0
leaq -0x88(%rbp), %rdi
movl $0xa, %esi
callq 0x2280
leaq -0x88(%rbp), %rdi
callq 0x2200
jmp 0x96d9
jmp 0x96db
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: set_rawmode
void set_rawmode(int fd, struct termios *save_tm)
{
	struct termios tm;

	tm = *save_tm;
	tm.c_iflag     = tm.c_oflag = 0;
	tm.c_cflag    &= ~CSIZE;
	tm.c_cflag    |= CS8;
	tm.c_lflag    &= ~(ECHO | ISIG | ICANON);
	tm.c_cc[VMIN]  = 1; /* min data size (byte) */
	tm.c_cc[VTIME] = 0; /* time out */
	etcsetattr(fd, TCSAFLUSH, &tm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x4c(%rbp), %rdi
movl $0x3c, %edx
callq 0x21c0
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x44(%rbp), %eax
andl $-0x31, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
andl $-0xc, %eax
movl %eax, -0x40(%rbp)
movb $0x1, -0x35(%rbp)
movb $0x0, -0x36(%rbp)
movl -0x4(%rbp), %edi
movl $0x2, %esi
leaq -0x4c(%rbp), %rdx
callq 0x2b50
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: tty_init
bool tty_init(struct termios *termios_orig)
{
	struct sigaction sigact;

	memset(&sigact, 0, sizeof(struct sigaction));
	sigact.sa_handler = sig_handler;
	sigact.sa_flags   = SA_RESTART;
	esigaction(SIGCHLD, &sigact, NULL);

	if (VT_CONTROL) {
		esigaction(SIGUSR1, &sigact, NULL);
		esigaction(SIGUSR2, &sigact, NULL);

		struct vt_mode vtm;
		vtm.mode   = VT_PROCESS;
		vtm.waitv  = 0;
		vtm.acqsig = SIGUSR1;
		vtm.relsig = SIGUSR2;
		vtm.frsig  = 0;

		if (ioctl(STDIN_FILENO, VT_SETMODE, &vtm))
			logging(WARN, "ioctl: VT_SETMODE failed (maybe here is not console)\n");

		if (FORCE_TEXT_MODE == false) {
			if (ioctl(STDIN_FILENO, KDSETMODE, KD_GRAPHICS))
				logging(WARN, "ioctl: KDSETMODE failed (maybe here is not console)\n");
		}
	}

	etcgetattr(STDIN_FILENO, termios_orig);
	set_rawmode(STDIN_FILENO, termios_orig);
	ewrite(STDIN_FILENO, "\033[?25l", 6); /* make cusor invisible */

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2120
leaq -0x169(%rip), %rax      # 0x9620
movq %rax, -0xa0(%rbp)
movl $0x10000000, -0x18(%rbp) # imm = 0x10000000
movl $0x11, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a80
movl $0xa, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a80
movl $0xc, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2a80
movb $0x1, -0xa8(%rbp)
movb $0x0, -0xa7(%rbp)
movw $0xa, -0xa4(%rbp)
movw $0xc, -0xa6(%rbp)
movw $0x0, -0xa2(%rbp)
xorl %edi, %edi
movl $0x5602, %esi           # imm = 0x5602
leaq -0xa8(%rbp), %rdx
movb $0x0, %al
callq 0x2130
cmpl $0x0, %eax
je 0x982c
movl $0x1, %edi
leaq 0x4c77f(%rip), %rsi     # 0x55fa4
movb $0x0, %al
callq 0x2450
xorl %edi, %edi
movl $0x4b3a, %esi           # imm = 0x4B3A
movl $0x1, %edx
movb $0x0, %al
callq 0x2130
cmpl $0x0, %eax
je 0x9857
movl $0x1, %edi
leaq 0x4c78a(%rip), %rsi     # 0x55fda
movb $0x0, %al
callq 0x2450
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x2af0
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0x96f0
xorl %edi, %edi
leaq 0x4c799(%rip), %rsi     # 0x5600f
movl $0x6, %edx
callq 0x2930
movb $0x1, %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: tty_die
void tty_die(struct termios *termios_orig)
{
 	/* no error handling */
	struct sigaction sigact;
	struct vt_mode vtm;

	memset(&sigact, 0, sizeof(struct sigaction));
	sigact.sa_handler = SIG_DFL;
	sigaction(SIGCHLD, &sigact, NULL);

	if (VT_CONTROL) {
		sigaction(SIGUSR1, &sigact, NULL);
		sigaction(SIGUSR2, &sigact, NULL);

		vtm.mode   = VT_AUTO;
		vtm.waitv  = 0;
		vtm.relsig = vtm.acqsig = vtm.frsig = 0;

		ioctl(STDIN_FILENO, VT_SETMODE, &vtm);

		if (FORCE_TEXT_MODE == false)
			ioctl(STDIN_FILENO, KDSETMODE, KD_TEXT);
	}

	tcsetattr(STDIN_FILENO, TCSAFLUSH, termios_orig);
	fflush(stdout);
	ewrite(STDIN_FILENO, "\033[?25h", 6); /* make cursor visible */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2120
movq $0x0, -0xa0(%rbp)
movl $0x11, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2090
movl $0xa, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2090
movl $0xc, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2090
movb $0x0, -0xa8(%rbp)
movb $0x0, -0xa7(%rbp)
movw $0x0, -0xa2(%rbp)
movw $0x0, -0xa4(%rbp)
movw $0x0, -0xa6(%rbp)
xorl %edi, %edi
movl $0x5602, %esi           # imm = 0x5602
leaq -0xa8(%rbp), %rdx
movb $0x0, %al
callq 0x2130
xorl %edx, %edx
movl $0x4b3a, %esi           # imm = 0x4B3A
movl %edx, %edi
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rdx
xorl %edi, %edi
movl $0x2, %esi
callq 0x2250
movq 0x4f667(%rip), %rax     # 0x58fc8
movq (%rax), %rdi
callq 0x21f0
xorl %edi, %edi
leaq 0x4c6a4(%rip), %rsi     # 0x56016
movl $0x6, %edx
callq 0x2930
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: fork_and_exec
bool fork_and_exec(int *master, const char *cmd, char *const argv[], int lines, int cols)
{
	pid_t pid;
	struct winsize ws = {.ws_row = lines, .ws_col = cols,
		/* XXX: this variables are UNUSED (man tty_ioctl),
			but useful for calculating terminal cell size */
		.ws_ypixel = CELL_HEIGHT * lines, .ws_xpixel = CELL_WIDTH * cols};

	pid = eforkpty(master, NULL, NULL, &ws);
	if (pid < 0)
		return false;
	else if (pid == 0) { /* child */
		esetenv("TERM", term_name, 1);
		eexecvp(cmd, argv);
		/* never reach here */
		exit(EXIT_FAILURE);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl -0x24(%rbp), %eax
movw %ax, -0x34(%rbp)
movl -0x28(%rbp), %eax
movw %ax, -0x32(%rbp)
movl -0x28(%rbp), %eax
shll $0x3, %eax
movw %ax, -0x30(%rbp)
movl -0x24(%rbp), %eax
shll $0x4, %eax
movw %ax, -0x2e(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x34(%rbp), %rcx
movq %rdx, %rsi
callq 0x2cc0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x99f0
movb $0x0, -0x1(%rbp)
jmp 0x9a2b
cmpl $0x0, -0x2c(%rbp)
jne 0x9a25
movq 0x4f7cb(%rip), %rsi     # 0x591c8
leaq 0x4c619(%rip), %rdi     # 0x5601d
movl $0x1, %edx
callq 0x2de0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2e50
movl $0x1, %edi
callq 0x22c0
jmp 0x9a27
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/yaft.c
// Function: check_fds
int check_fds(fd_set *fds, struct timeval *tv, int input, int master)
{
	FD_ZERO(fds);
	FD_SET(input, fds);
	FD_SET(master, fds);
	tv->tv_sec  = 0;
	tv->tv_usec = SELECT_TIMEOUT;
	return eselect(master + 1, fds, NULL, NULL, tv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x10, %rax
jae 0x9a88
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9a65
jmp 0x9a8a
movl -0x14(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x48(%rbp), %rdx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x38(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x3a98, 0x8(%rax)      # imm = 0x3A98
movl -0x18(%rbp), %edi
addl $0x1, %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x2890
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./fb/common.h
// Function: draw_sixel
static inline void draw_sixel(struct framebuffer_t *fb, int line, int col, uint8_t *pixmap)
{
	int h, w, src_offset, dst_offset;
	uint32_t pixel, color = 0;

	for (h = 0; h < CELL_HEIGHT; h++) {
		for (w = 0; w < CELL_WIDTH; w++) {
			src_offset = BYTES_PER_PIXEL * (h * CELL_WIDTH + w);
			memcpy(&color, pixmap + src_offset, BYTES_PER_PIXEL);

			dst_offset = (line * CELL_HEIGHT + h) * fb->info.line_length
				+ (col * CELL_WIDTH + w) * fb->info.bytes_per_pixel;
			pixel = color2pixel(&fb->info, color);
			memcpy(fb->buf + dst_offset, &pixel, fb->info.bytes_per_pixel);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x9f50
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x9f40
movl -0x1c(%rbp), %eax
shll $0x3, %eax
addl -0x20(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
addl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x448(%rcx), %eax
movl -0x10(%rbp), %ecx
shll $0x3, %ecx
addl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x44c(%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x420, %rdi            # imm = 0x420
movl -0x30(%rbp), %esi
callq 0x4160
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq 0x44c(%rax), %rdx
leaq -0x2c(%rbp), %rsi
callq 0x21c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9ea5
jmp 0x9f42
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9e94
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: hls2rgb
static inline uint32_t hls2rgb(int hue, int lum, int sat)
{
	uint32_t r, g, b;
	int magic1, magic2;

	if (sat == 0) {
		r = g = b = (lum * RGBMAX) / LSMAX;
	} else {
		if (lum <= (LSMAX / 2) )
			magic2 = (lum * (LSMAX + sat) + (LSMAX / 2)) / LSMAX;
		else
			magic2 = lum + sat - ((lum * sat) + (LSMAX / 2)) / LSMAX;
		magic1 = 2 * lum - magic2;

		r = (hue2rgb(magic1, magic2, hue + (HUEMAX / 3)) * RGBMAX + (LSMAX / 2)) / LSMAX;
		g = (hue2rgb(magic1, magic2, hue) * RGBMAX + (LSMAX / 2)) / LSMAX;
		b = (hue2rgb(magic1, magic2, hue - (HUEMAX / 3)) * RGBMAX + (LSMAX/2)) / LSMAX;
	}
	return (r << 16) + (g << 8) + b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x9f94
imull $0xff, -0x8(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl %eax, -0x14(%rbp)
movl %eax, -0x10(%rbp)
jmp 0xa055
cmpl $0x32, -0x8(%rbp)
jg 0x9fb6
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x64, %ecx
imull %ecx, %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x9fdb
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x8(%rbp), %eax
imull -0xc(%rbp), %eax
addl $0x32, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
shll %eax
subl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x4(%rbp), %edx
addl $0x78, %edx
callq 0xa070
imull $0xff, %eax, %eax
addl $0x32, %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0xa070
imull $0xff, %eax, %eax
addl $0x32, %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x4(%rbp), %edx
subl $0x78, %edx
callq 0xa070
imull $0xff, %eax, %eax
addl $0x32, %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
shll $0x10, %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: hue2rgb
static inline uint32_t hue2rgb(int n1, int n2, int hue)
{
	if (hue < 0)
		hue += HUEMAX;

	if (hue > HUEMAX)
		hue -= HUEMAX;

	if (hue < (HUEMAX / 6))
		return (n1 + (((n2 - n1) * hue + (HUEMAX / 12)) / (HUEMAX / 6)));
	if (hue < (HUEMAX / 2))
		return n2;
	if (hue < ((HUEMAX * 2) / 3))
		return (n1 + (((n2 - n1) * (((HUEMAX * 2) / 3) - hue) + (HUEMAX / 12)) / (HUEMAX / 6)));
	else
		return n1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xa08e
movl -0x10(%rbp), %eax
addl $0x168, %eax            # imm = 0x168
movl %eax, -0x10(%rbp)
cmpl $0x168, -0x10(%rbp)     # imm = 0x168
jle 0xa0a2
movl -0x10(%rbp), %eax
subl $0x168, %eax            # imm = 0x168
movl %eax, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0xa0cf
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
imull -0x10(%rbp), %eax
addl $0x1e, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xa11d
cmpl $0xb4, -0x10(%rbp)
jge 0xa0e0
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa11d
cmpl $0xf0, -0x10(%rbp)
jge 0xa117
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
movl $0xf0, %ecx
subl -0x10(%rbp), %ecx
imull %ecx, %eax
addl $0x1e, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xa11d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/buffer.c
// Function: main
int main(int argc, char * argv[])
{
	int ret;
	char buf[65536];
	(void) argc;

	ret = _buffer(argv[0], 0, NULL);
	ret |= _buffer(argv[0], sizeof(buf), NULL);
	memset(buf, 0, sizeof(buf));
	ret |= _buffer(argv[0], sizeof(buf), buf);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10020, %rsp          # imm = 0x10020
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1260
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
movl %eax, %edx
callq 0x1260
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x10020(%rbp), %rdi
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x1070
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x10020(%rbp), %rdx
movl $0x10000, %esi          # imm = 0x10000
callq 0x1260
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x10020, %rsp          # imm = 0x10020
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/buffer.c
// Function: buffer
static int _buffer(String const * progname, size_t size, char const * data)
{
	int ret = 0;
	Buffer * buffer;

	printf("%s: Testing buffer_new()\n", progname);
	fflush(stdout);
	if((buffer = buffer_new(size, data)) == NULL)
	{
		error_print(progname);
		return 2;
	}
	if(buffer_get_size(buffer) != size)
		ret = 3;
	if(buffer_get_data(buffer) == NULL && size != 0)
		ret = 4;
	if(buffer_set(buffer, size, data) != 0
			|| buffer_set(buffer, size, NULL) != 0)
		ret = 5;
	if(buffer_set_size(buffer, size) != 0
			|| buffer_set_size(buffer, 0) != 0)
		ret = 6;
	buffer_delete(buffer);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xd7e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movq 0x2d4c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1030
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x12c8
movq -0x10(%rbp), %rdi
callq 0x10b0
movl $0x2, -0x4(%rbp)
jmp 0x1368
movq -0x30(%rbp), %rdi
callq 0x1050
cmpq -0x18(%rbp), %rax
je 0x12de
movl $0x3, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10a0
cmpq $0x0, %rax
jne 0x12fb
cmpq $0x0, -0x18(%rbp)
je 0x12fb
movl $0x4, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1080
cmpl $0x0, %eax
jne 0x1327
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
cmpl $0x0, %eax
je 0x132e
movl $0x5, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x1352
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
cmpl $0x0, %eax
je 0x1359
movl $0x6, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_ln.c
// Function: get_last_file_name
char *get_last_file_name(char *path){

    //take out the last / and get the file name (could be a dir)
    if (path[strlen(path) -1] == '/') path[strlen(path)-1] = '\0';

    // get the file name that is to be linked (first file)
    int i;
    int file_len1 = 0;
    for (i = strlen(path); path[i] != '/'; i--) {
        file_len1++;
        if (file_len1 > 255) {
            fprintf(stderr, "File name too large.\n");
            exit(1);
        }
    }

    //copy the new file name
    char *file_name = malloc(sizeof(char) * file_len1);
    strcpy(file_name, path + i + 1);

    return file_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x17c1
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x1826
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0x10(%rbp)
jle 0x1819
movq 0x37fa(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1812(%rip), %rsi      # 0x301a
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
jmp 0x181b
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17d4
movslq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x1050
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_ln.c
// Function: check_path
int check_path(char *path){
    if(path[0] != '/'){
        return 1;
    } else {
        return 0;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x187d
movl $0x1, -0x4(%rbp)
jmp 0x1884
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/journal.c
// Function: dump_info
static void dump_info(struct dhara_journal *j)
{
	printf("    log2_ppc   = %d\n", j->log2_ppc);
	printf("    size       = %d\n", dhara_journal_size(j));
	printf("    capacity   = %d\n", dhara_journal_capacity(j));
	printf("    bb_current = %d\n", j->bb_current);
	printf("    bb_last    = %d\n", j->bb_last);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movzbl 0x10(%rax), %esi
leaq 0x1db2(%rip), %rdi      # 0x50c6
movb $0x0, %al
callq 0x1050
movq (%rsp), %rdi
callq 0x1cb0
movl %eax, %esi
leaq 0x1dae(%rip), %rdi      # 0x50db
movb $0x0, %al
callq 0x1050
movq (%rsp), %rdi
callq 0x1c20
movl %eax, %esi
leaq 0x1daa(%rip), %rdi      # 0x50f0
movb $0x0, %al
callq 0x1050
movq (%rsp), %rax
movl 0x14(%rax), %esi
leaq 0x1daa(%rip), %rdi      # 0x5105
movb $0x0, %al
callq 0x1050
movq (%rsp), %rax
movl 0x18(%rax), %esi
leaq 0x1daa(%rip), %rdi      # 0x511a
movb $0x0, %al
callq 0x1050
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/journal.c
// Function: suspend_resume
static void suspend_resume(struct dhara_journal *j)
{
	const dhara_page_t old_root = dhara_journal_root(j);
	const dhara_page_t old_tail = j->tail;
	const dhara_page_t old_head = j->head;
	dhara_error_t err;

	dhara_journal_clear(j);
	assert(dhara_journal_root(j) == DHARA_PAGE_NONE);

	if (dhara_journal_resume(j, &err) < 0)
		dabort("resume", err);

	assert(old_root == dhara_journal_root(j));
	assert(old_tail == j->tail);
	assert(old_head == j->head);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x34f0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2200
movq 0x20(%rsp), %rdi
callq 0x34f0
cmpl $-0x1, %eax
jne 0x340a
jmp 0x3429
leaq 0x1d1e(%rip), %rdi      # 0x512f
leaq 0x1c27(%rip), %rsi      # 0x503f
movl $0x22, %edx
leaq 0x1d34(%rip), %rcx      # 0x5158
callq 0x1060
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1330
cmpl $0x0, %eax
jge 0x344d
movl 0x10(%rsp), %esi
leaq 0x1d3c(%rip), %rdi      # 0x5184
callq 0x4110
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x34f0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jne 0x346b
jmp 0x348a
leaq 0x1d19(%rip), %rdi      # 0x518b
leaq 0x1bc6(%rip), %rsi      # 0x503f
movl $0x27, %edx
leaq 0x1cd3(%rip), %rcx      # 0x5158
callq 0x1060
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x349a
jmp 0x34b9
leaq 0x1d0c(%rip), %rdi      # 0x51ad
leaq 0x1b97(%rip), %rsi      # 0x503f
movl $0x28, %edx
leaq 0x1ca4(%rip), %rcx      # 0x5158
callq 0x1060
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x34c9
jmp 0x34e8
leaq 0x1cf1(%rip), %rdi      # 0x51c1
leaq 0x1b68(%rip), %rsi      # 0x503f
movl $0x29, %edx
leaq 0x1c75(%rip), %rcx      # 0x5158
callq 0x1060
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/jtutil.c
// Function: jt_check
void jt_check(struct dhara_journal *j)
{
	/* Head and tail pointers always point to a valid user-page
	 * index (never a meta-page, and never out-of-bounds).
	 */
	check_upage(j, j->head);
	check_upage(j, j->tail);
	check_upage(j, j->tail_sync);

	/* The head never advances forward onto the same block as the
	 * tail.
	 */
	if (!((j->head ^ j->tail_sync) >> j->nand->log2_ppb)) {
		assert(j->head >= j->tail_sync);
	}

	/* The current tail is always between the head and the
	 * synchronized tail.
	 */
	assert((j->head - j->tail_sync) >= (j->tail - j->tail_sync));

	/* The root always points to a valid user page in a non-empty
	 * journal.
	 */
	if (j->root != DHARA_PAGE_NONE) {
		const dhara_page_t raw_size = j->head - j->tail;
		const dhara_page_t root_offset = j->root - j->tail;

		check_upage(j, j->root);
		assert(root_offset < raw_size);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x24(%rax), %esi
callq 0x4320
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x4320
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %esi
callq 0x4320
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x10(%rsp), %rcx
xorl 0x1c(%rcx), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shrl %cl, %eax
cmpl $0x0, %eax
jne 0x4257
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0x4236
jmp 0x4255
leaq 0x13cf(%rip), %rdi      # 0x560c
leaq 0x13e0(%rip), %rsi      # 0x5624
movl $0x2d, %edx
leaq 0x13e3(%rip), %rcx      # 0x5633
callq 0x1060
jmp 0x4257
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x1c(%rcx), %eax
movq 0x10(%rsp), %rcx
movl 0x20(%rcx), %ecx
movq 0x10(%rsp), %rdx
subl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jb 0x427d
jmp 0x429c
leaq 0x13d5(%rip), %rdi      # 0x5659
leaq 0x1399(%rip), %rsi      # 0x5624
movl $0x33, %edx
leaq 0x139c(%rip), %rcx      # 0x5633
callq 0x1060
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x430e
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x4320
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0x42ed
jmp 0x430c
leaq 0x139a(%rip), %rdi      # 0x568e
leaq 0x1329(%rip), %rsi      # 0x5624
movl $0x3d, %edx
leaq 0x132c(%rip), %rcx      # 0x5633
callq 0x1060
jmp 0x430e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/jtutil.c
// Function: jt_enqueue_sequence
int jt_enqueue_sequence(struct dhara_journal *j, int start, int count)
{
	int i;

	if (count < 0)
		count = j->nand->num_blocks << j->nand->log2_ppb;

	for (i = 0; i < count; i++) {
		uint8_t meta[DHARA_META_SIZE];
		dhara_page_t root;
		dhara_error_t err;

		if (enqueue(j, start + i, &err) < 0) {
			if (err == DHARA_E_JOURNAL_FULL)
				return i;

			dabort("enqueue", err);
		}

		assert(dhara_journal_size(j) >= i);
		root = dhara_journal_root(j);

		if (dhara_journal_read_meta(j, root, meta, &err) < 0)
			dabort("read_meta", err);
		assert(dhara_r32(meta) == start + i);
	}

	return count;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movl %edx, 0xa0(%rsp)
cmpl $0x0, 0xa0(%rsp)
jge 0x440d
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll %cl, %eax
movl %eax, 0xa0(%rsp)
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
cmpl 0xa0(%rsp), %eax
jge 0x4548
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl 0x9c(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x4570
cmpl $0x0, %eax
jge 0x447b
cmpl $0x5, 0x8(%rsp)
jne 0x446b
movl 0x9c(%rsp), %eax
movl %eax, 0xb4(%rsp)
jmp 0x4556
movl 0x8(%rsp), %esi
leaq 0x122f(%rip), %rdi      # 0x56a5
callq 0x4110
movq 0xa8(%rsp), %rdi
callq 0x1cb0
cmpl 0x9c(%rsp), %eax
jb 0x4493
jmp 0x44b2
leaq 0x1213(%rip), %rdi      # 0x56ad
leaq 0x1183(%rip), %rsi      # 0x5624
movl $0x9a, %edx
leaq 0x121b(%rip), %rcx      # 0x56c8
callq 0x1060
movq 0xa8(%rsp), %rdi
callq 0x46b0
movl %eax, 0xc(%rsp)
movq 0xa8(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x1d70
cmpl $0x0, %eax
jge 0x44f3
movl 0x8(%rsp), %esi
leaq 0x1214(%rip), %rdi      # 0x5702
callq 0x4110
leaq 0x10(%rsp), %rdi
callq 0x46c0
movl 0xa4(%rsp), %ecx
addl 0x9c(%rsp), %ecx
cmpl %ecx, %eax
jne 0x4511
jmp 0x4530
leaq 0x11f4(%rip), %rdi      # 0x570c
leaq 0x1105(%rip), %rsi      # 0x5624
movl $0x9f, %edx
leaq 0x119d(%rip), %rcx      # 0x56c8
callq 0x1060
jmp 0x4532
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x4418
movl 0xa0(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/jtutil.c
// Function: enqueue
static int enqueue(struct dhara_journal *j, uint32_t id, dhara_error_t *err)
{
	const int page_size = 1 << j->nand->log2_page_size;
	uint8_t r[page_size];
	uint8_t meta[DHARA_META_SIZE];
	dhara_error_t my_err;
	int i;

	seq_gen(id, r, page_size);
	dhara_w32(meta, id);

	for (i = 0; i < DHARA_MAX_RETRIES; i++) {
		jt_check(j);
		if (!dhara_journal_enqueue(j, r, meta, &my_err))
			return 0;

		if (my_err != DHARA_E_RECOVER) {
			dhara_set_error(err, my_err);
			return -1;
		}

		recover(j);
	}

	dhara_set_error(err, DHARA_E_TOO_BAD);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0xd8(%rbp)
movq %rsi, %rsp
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edi
movslq -0x24(%rbp), %rdx
callq 0x4000
leaq -0xc0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4940
movl $0x0, -0xc8(%rbp)
cmpl $0x8, -0xc8(%rbp)
jge 0x467b
movq -0x10(%rbp), %rdi
callq 0x41c0
movq -0xd8(%rbp), %rsi
movq -0x10(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
leaq -0xc4(%rbp), %rcx
callq 0x2250
cmpl $0x0, %eax
jne 0x4633
movl $0x0, -0x4(%rbp)
movl $0x1, -0xcc(%rbp)
jmp 0x469a
cmpl $0x4, -0xc4(%rbp)
je 0x465e
movq -0x20(%rbp), %rdi
movl -0xc4(%rbp), %esi
callq 0x4990
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0xcc(%rbp)
jmp 0x469a
movq -0x10(%rbp), %rdi
callq 0x49b0
movl -0xc8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc8(%rbp)
jmp 0x45e7
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x4990
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0xcc(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/jtutil.c
// Function: recover
static void recover(struct dhara_journal *j)
{
	int retry_count = 0;

	printf("    recover: start\n");

	while (dhara_journal_in_recovery(j)) {
		const dhara_page_t p = dhara_journal_next_recoverable(j);
		dhara_error_t err;
		int ret;

		jt_check(j);

		if (p == DHARA_PAGE_NONE) {
			ret = dhara_journal_enqueue(j, NULL, NULL, &err);
		} else {
			uint8_t meta[DHARA_META_SIZE];

			if (dhara_journal_read_meta(j, p, meta, &err) < 0)
				dabort("read_meta", err);

			ret = dhara_journal_copy(j, p, meta, &err);
		}

		jt_check(j);

		if (ret < 0) {
			if (err == DHARA_E_RECOVER) {
				printf("    recover: restart\n");
				if (++retry_count >= DHARA_MAX_RETRIES)
					dabort("recover", DHARA_E_TOO_BAD);
				continue;
			}

			dabort("copy", err);
		}
	}

	jt_check(j);
	printf("    recover: complete\n");
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movl $0x0, 0x9c(%rsp)
leaq 0xe6f(%rip), %rdi       # 0x5840
movb $0x0, %al
callq 0x1050
movq 0xa0(%rsp), %rdi
callq 0x4b40
cmpl $0x0, %eax
je 0x4b0e
movq 0xa0(%rsp), %rdi
callq 0x2960
movl %eax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x41c0
cmpl $-0x1, 0x98(%rsp)
jne 0x4a3e
movq 0xa0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq 0x94(%rsp), %rcx
movq %rdx, %rsi
callq 0x2250
movl %eax, 0x90(%rsp)
jmp 0x4a9b
movq 0xa0(%rsp), %rdi
movl 0x98(%rsp), %esi
movq %rsp, %rdx
leaq 0x94(%rsp), %rcx
callq 0x1d70
cmpl $0x0, %eax
jge 0x4a75
movl 0x94(%rsp), %esi
leaq 0xc92(%rip), %rdi       # 0x5702
callq 0x4110
movq 0xa0(%rsp), %rdi
movl 0x98(%rsp), %esi
movq %rsp, %rdx
leaq 0x94(%rsp), %rcx
callq 0x2890
movl %eax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x41c0
cmpl $0x0, 0x90(%rsp)
jge 0x4b09
cmpl $0x4, 0x94(%rsp)
jne 0x4af6
leaq 0xd91(%rip), %rdi       # 0x5854
movb $0x0, %al
callq 0x1050
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
cmpl $0x8, %eax
jl 0x4af1
leaq 0xd83(%rip), %rdi       # 0x586a
movl $0x3, %esi
callq 0x4110
jmp 0x49d8
movl 0x94(%rsp), %esi
leaq 0xd6e(%rip), %rdi       # 0x5872
callq 0x4110
jmp 0x49d8
movq 0xa0(%rsp), %rdi
callq 0x41c0
leaq 0xd55(%rip), %rdi       # 0x5877
movb $0x0, %al
callq 0x1050
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/fgfl.c
// Function: main
int
main(int argc, char const* argv[]) {
    if (argc <= 1)
        { return (EXIT_FAILURE); }

    int filde = open(argv[1], O_RDONLY);
    if (filde == -1) {
        errorf(0, "Can't open %s.", argv[1]);
        return (EXIT_FAILURE);
    }

    lexical_spec_t* spec = parse_lexical_spec(filde);
    if (!spec)
        { exit(EXIT_FAILURE); }
    
    if (spec_sanity_check(spec) == ERROR) {
        del_lexical_spec(spec);
        return (EXIT_FAILURE);
    }

//  print_token_entry(spec);
    if (build_nfa(spec) == ERROR) {
        errorf(0, "Impossible to construct the NFA automaton.");
        return (EXIT_FAILURE);
    }

    int exit_st = gen_fgfl_file(spec, get_filename(argv[1]));
    del_lexical_spec(spec);

    if (close(filde) == -1) {
        errorf(0, "Can't close %s.", argv[1]);
        return (EXIT_FAILURE);
    }

    return (exit_st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x44b8
movl $0x1, -0x4(%rbp)
jmp 0x45c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1150
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x44f8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x9e88(%rip), %rsi      # 0xe36d
movb $0x0, %al
callq 0x4230
movl $0x1, -0x4(%rbp)
jmp 0x45c4
movl -0x14(%rbp), %edi
callq 0x4b60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4515
movl $0x1, %edi
callq 0x1180
movq -0x20(%rbp), %rdi
callq 0x4c50
cmpl $-0x1, %eax
jne 0x4538
movq -0x20(%rbp), %rdi
callq 0x4840
movl $0x1, -0x4(%rbp)
jmp 0x45c4
movq -0x20(%rbp), %rdi
callq 0x67e0
cmpl $-0x1, %eax
jne 0x4561
xorl %eax, %eax
movl %eax, %edi
leaq 0x9e2b(%rip), %rsi      # 0xe37c
movb $0x0, %al
callq 0x4230
movl $0x1, -0x4(%rbp)
jmp 0x45c4
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3930
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x45d0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4840
movl -0x14(%rbp), %edi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x45be
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x9df9(%rip), %rsi      # 0xe3a7
movb $0x0, %al
callq 0x4230
movl $0x1, -0x4(%rbp)
jmp 0x45c4
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/fgfl.c
// Function: gen_dfa_final_tables
static inline void
gen_dfa_final_tables(int filde, lexical_spec_t* spec, nfa_state_t* master,
                                    char const* header, spec_entry_t* state) {
    build_dfa_table(master, spec);

    gen_state_table(filde, spec, header, state);
    gen_ahead_table(filde, spec, header, state);

    GEN_FINAL_TABLE(filde, spec, header, state);
    GEN_ANCHOR_FINAL_TABLE(filde, spec, header, state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb890
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xc970
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xcbd0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x2, %r8d
callq 0xcd00
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x3, %r8d
callq 0xcd00
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: del_lexical_spec
void
del_lexical_spec(lexical_spec_t* spec) {
    if (spec) {
        foreach_vector(spec->entry_vect, &del_spec_entry);
        foreach_vector(spec->state_vect, &del_spec_entry);
    
        del_vector(spec->entry_vect);
        del_vector(spec->state_vect);

        del_lexer(spec->lex);

        foreach_vector(spec->states, &del_dfa_state);
        del_vector(spec->states);
    }
    FREE(spec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48c2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7e(%rip), %rsi        # 0x48e0
callq 0x23c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x6a(%rip), %rsi        # 0x48e0
callq 0x23c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2010
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2010
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2c10
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x6fa0(%rip), %rsi      # 0xb850
callq 0x23c0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2010
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: del_spec_entry
static void
del_spec_entry(spec_entry_t* entry) {
    if (entry) {
        if (entry->kind == T_TERMINAL) {
            del_regex_node(entry->regex_ast);
            del_trans_list(entry->state_lst);
        }
        FREE(entry->name);
    }
    FREE(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4924
movq -0x8(%rbp), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x4917
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa380
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3c00
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_token_section
int
spec_token_section(lexical_spec_t* spec) {
    bool empty = true;
    while (peek_token(spec->lex) != T_EOF) {
        if (spec_token_entry_section(spec) == ERROR)
            { return (ERROR); }
        empty = false;
    }
    if (empty)
        { warnf(0, "Empty file. No output generated."); }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3300
cmpl $0x70, %eax
je 0x49ae
movq -0x10(%rbp), %rdi
callq 0x49e0
cmpl $-0x1, %eax
jne 0x49a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x49cd
movb $0x0, -0x11(%rbp)
jmp 0x4980
testb $0x1, -0x11(%rbp)
je 0x49c6
xorl %eax, %eax
movl %eax, %edi
leaq 0x9a67(%rip), %rsi      # 0xe426
movb $0x0, %al
callq 0x43e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: parse_lexical_spec
lexical_spec_t*
parse_lexical_spec(int filde) {
    lexical_spec_t* crt_spec = new_lexical_spec(filde);
    if (spec_token_section(crt_spec) == ERROR) {
        del_lexical_spec(crt_spec);
        return (NULL);
    }
    return (crt_spec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x4bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4970
cmpl $-0x1, %eax
jne 0x4b98
movq -0x18(%rbp), %rdi
callq 0x4840
movq $0x0, -0x8(%rbp)
jmp 0x4ba0
movq -0x18(%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/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: new_lexical_spec
static lexical_spec_t*
new_lexical_spec(int filde) {
    lexical_spec_t* crt_spec = NEW(lexical_spec_t, 1);

    if (!crt_spec)
        { return (NULL); }
    memset(crt_spec, 0, sizeof(lexical_spec_t));

    crt_spec->lex = new_lexer(filde);
    crt_spec->entry_vect = new_vector();
    crt_spec->state_vect = new_vector();

    crt_spec->start_state = -1;
    crt_spec->miss_regex = true;

    return (crt_spec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x40, %edi
callq 0x38d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4bda
movq $0x0, -0x8(%rbp)
jmp 0x4c37
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10b0
movl -0xc(%rbp), %edi
callq 0x2b60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0x1f00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x1f00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_sanity_check
int
spec_sanity_check(lexical_spec_t* spec) {
    if (!spec)
        { return (ERROR); }
    else if (spec->start_state == -1 && !EMPTY_VECTOR(spec->state_vect)) {
        spec_entry_t* state_init = (spec_entry_t*)
                                        AT_VECTOR(spec->state_vect, 0);

        warnf(0, "Initial state not defined. Default set to state %s.",
                                        state_init->name);
        spec->start_state = 0;
    }

    if (expand_macro_regex(spec) == ERROR)
        { return (ERROR); }
    else if (check_validity_token(spec) == ERROR)
        { return (ERROR); }
    else if (check_validity_state(spec) == ERROR)
        { return (ERROR); }

    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c6f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d11
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x4cbf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x4cbf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x979a(%rip), %rsi      # 0xe447
movb $0x0, %al
callq 0x43e0
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0x4cc1
movq -0x10(%rbp), %rdi
callq 0xb460
cmpl $-0x1, %eax
jne 0x4cd8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d11
movq -0x10(%rbp), %rdi
callq 0x4d20
cmpl $-0x1, %eax
jne 0x4cef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d11
movq -0x10(%rbp), %rdi
callq 0x4eb0
cmpl $-0x1, %eax
jne 0x4d06
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d11
jmp 0x4d08
jmp 0x4d0a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)