LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: decdld_parse_data
void decdld_parse_data(char *start_buf, int start_char, struct glyph_t *chars)
{
	/*
	DECDLD sixel data
		';': glyph separator
		'/': line feed
		sixel bitmap:
			range of ? (hex 3F) to ~ (hex 7E)
			? (hex 3F) represents the binary value 00 0000.
			t (hex 74) represents the binary value 11 0101.
			~ (hex 7E) represents the binary value 11 1111.
	*/
	char *cp, *end_buf;
	uint8_t char_num = start_char; /* start_char == 0 means SPACE(0x20) */
	uint8_t bitmap, row = 0, column = 0;

	init_glyph(&chars[char_num]);
	cp      = start_buf;
	end_buf = cp + strlen(cp);

	while (cp < end_buf) {
		if ('?' <= *cp && *cp <= '~') { /* sixel bitmap */
			logging(DEBUG, "char_num(ten):0x%.2X\n", char_num);
			/* remove offset '?' and use only 6bit */
			bitmap = bit_mask[BITS_PER_SIXEL] & (*cp - '?');
			decdld_bitmap(&chars[char_num], bitmap, row, column);
			column++;
		} else if (*cp == ';') {  /* next char */
			row = column = 0;
			char_num++;
			init_glyph(&chars[char_num]);
		} else if (*cp == '/') {  /* sixel nl+cr */
			row++;
			column = 0;
		} else if (*cp == '\0') { /* end of DECDLD sequence */
			break;
		}
		cp++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movzbl %bpl, %eax
leaq (%rax,%rax,4), %rax
movb $0x1, 0x4(%rdx,%rax,8)
movl $0x0, (%rdx,%rax,8)
xorps %xmm0, %xmm0
movups %xmm0, 0x6(%rdx,%rax,8)
movups %xmm0, 0x16(%rdx,%rax,8)
callq 0x20d0
xorps %xmm0, %xmm0
testq %rax, %rax
jle 0x6b35
addq %r14, %rax
leaq 0x6(%rbx), %rdx
xorl %edi, %edi
xorl %esi, %esi
movzbl (%r14), %r8d
leal -0x7f(%r8), %ecx
cmpb $-0x40, %cl
jae 0x6a9c
cmpl $0x2f, %r8d
je 0x6b24
cmpl $0x3b, %r8d
je 0x6aff
testl %r8d, %r8d
jne 0x6b29
jmp 0x6b35
cmpb $0x7, %dil
ja 0x6afa
incl %r8d
andl $0x3f, %r8d
movzbl %bpl, %r11d
movb $0x7, %cl
subb %dil, %cl
movzbl %sil, %r9d
leaq (%r9,%r9,2), %r15
addl %r9d, %r9d
leaq (%r9,%r9,2), %r9
movl $0x1, %r10d
shll %cl, %r10d
leaq (%r11,%r11,4), %rcx
shlq $0x2, %r15
leaq (%r15,%rcx,8), %rcx
addq %rdx, %rcx
xorl %r11d, %r11d
btl %r11d, %r8d
jae 0x6af1
leaq (%r9,%r11), %r15
cmpq $0xf, %r15
ja 0x6af1
orw %r10w, (%rcx,%r11,2)
incq %r11
cmpq $0x6, %r11
jne 0x6adc
incb %dil
jmp 0x6b29
incb %bpl
movzbl %bpl, %ecx
leaq (%rcx,%rcx,4), %rcx
movb $0x1, 0x4(%rbx,%rcx,8)
movl $0x0, (%rbx,%rcx,8)
movups %xmm0, 0x6(%rbx,%rcx,8)
movups %xmm0, 0x16(%rbx,%rcx,8)
xorl %esi, %esi
jmp 0x6b27
incb %sil
xorl %edi, %edi
incq %r14
cmpq %rax, %r14
jb 0x6a71
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/./parse.h
// Function: esc_sequence
void esc_sequence(struct terminal_t *term, uint8_t ch)
{
	*term->esc.bp = '\0';

	logging(DEBUG, "esc: ESC %s\n", term->esc.buf);

	if (strlen(term->esc.buf) == 1 && esc_func[ch])
		esc_func[ch](term);

	/* not reset if csi/osc/dcs seqence */
	if (ch == '[' || ch == ']' || ch == 'P')
		return;

	reset_esc(term);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movb $0x0, (%rax)
movq 0x68(%rdi), %rdi
callq 0x20d0
movzbl %bpl, %r14d
cmpq $0x1, %rax
jne 0x6d74
leaq 0x4f57a(%rip), %rax     # 0x562e0
movq (%rax,%r14,8), %rax
testq %rax, %rax
je 0x6d74
movq %rbx, %rdi
callq *%rax
addl $-0x50, %r14d
cmpl $0xd, %r14d
ja 0x6d89
movl $0x2801, %eax           # imm = 0x2801
btl %r14d, %eax
jb 0x6d98
movq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/./parse.h
// Function: csi_sequence
void csi_sequence(struct terminal_t *term, uint8_t ch)
{
	struct parm_t parm;

	*(term->esc.bp - 1) = '\0'; /* omit final character */

	logging(DEBUG, "csi: CSI %s\n", term->esc.buf + 1);

	reset_parm(&parm);
	parse_arg(term->esc.buf + 1, &parm, ';', isdigit); /* skip '[' */

	if (csi_func[ch])
		csi_func[ch](term, &parm);

	reset_esc(term);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movb $0x0, -0x1(%rax)
movq 0x68(%rdi), %r14
movl $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x80(%rsp)
incq %r14
movq %r14, %rdi
callq 0x20d0
testq %rax, %rax
je 0x6e93
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edi, %edi
xorl %edx, %edx
movsbl (%r14), %r8d
leal -0x3a(%r8), %r9d
cmpl $-0xa, %r9d
jb 0x6e1e
movq %r14, %r9
jmp 0x6e21
xorl %r9d, %r9d
testq %rdx, %rdx
cmoveq %r9, %rdx
cmpl $0x3b, %r8d
jne 0x6e53
movb $0x0, (%r14)
cmpl $0xf, %edi
jle 0x6e3c
xorl %r8d, %r8d
jmp 0x6e51
movslq %edi, %rcx
movq %rdx, 0x10(%rsp,%rcx,8)
incl %edi
movl %edi, 0x8(%rsp)
xorl %r8d, %r8d
movl %edi, %ecx
movl %edi, %esi
xorl %edx, %edx
cmpq $0x1, %rax
jne 0x6e87
testq %rdx, %rdx
je 0x6e67
movl %esi, %edi
cmpl $0xf, %esi
jle 0x6e75
jmp 0x6e87
testb %r8b, %r8b
jne 0x6e83
movl %ecx, %esi
movl %ecx, %edi
cmpl $0xf, %ecx
jg 0x6e87
movslq %esi, %rcx
movq %rdx, 0x10(%rsp,%rcx,8)
incl %ecx
movl %ecx, 0x8(%rsp)
movl %ecx, %esi
movl %ecx, %edi
incq %r14
decq %rax
jne 0x6e0b
movzbl %bpl, %eax
leaq 0x4f842(%rip), %rcx     # 0x566e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x6eb1
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/./parse.h
// Function: osc_sequence
void osc_sequence(struct terminal_t *term, uint8_t ch)
{
	int osc_mode;
	struct parm_t parm;

	omit_string_terminator(term->esc.bp, ch);

	logging(DEBUG, "osc: OSC %s\n", term->esc.buf);

	reset_parm(&parm);
	parse_arg(term->esc.buf + 1, &parm, ';', is_osc_parm); /* skip ']' */

	if (parm.argc > 0) {
		osc_mode = dec2num(parm.argv[0]);
		logging(DEBUG, "osc_mode:%d\n", osc_mode);

		/* XXX: disable because this functions only work 24/32bpp
			-> support other bpp (including pseudo color) */
		if (osc_mode == 4)
			set_palette(term, &parm);
		else if (osc_mode == 104)
			reset_palette(term, &parm);
		if (osc_mode == 8900)
			glyph_width_report(term, &parm);
	}
	reset_esc(term);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
xorl %ecx, %ecx
cmpl $0x5c, %esi
sete %cl
notq %rcx
movb $0x0, (%rax,%rcx)
movq %rsp, %r14
movl $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
movq 0x68(%rdi), %rdi
incq %rdi
leaq -0xaf(%rip), %rcx       # 0x6ecc
movq %r14, %rsi
movl $0x3b, %edx
callq 0x2dbf
cmpl $0x0, (%r14)
jle 0x6fda
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6fda
xorl %esi, %esi
movl $0xa, %edx
callq 0x2d12
cmpl $0x22c4, %eax           # imm = 0x22C4
je 0x6fcf
cmpl $0x68, %eax
je 0x6fc2
cmpl $0x4, %eax
jne 0x6fda
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a68
jmp 0x6fda
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5b75
jmp 0x6fda
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5c0a
movq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/./parse.h
// Function: dcs_sequence
void dcs_sequence(struct terminal_t *term, uint8_t ch)
{
	char *cp;

	omit_string_terminator(term->esc.bp, ch);

	logging(DEBUG, "dcs: DCS %s\n", term->esc.buf);

	/* check DCS header */
	cp = term->esc.buf + 1; /* skip P */
	while (cp < term->esc.bp) {
		if (*cp == '{' || *cp == 'q')                      /* DECDLD or sixel */
			break;
		else if (*cp == ';' || ('0' <= *cp && *cp <= '9')) /* valid DCS header */
			;
		else                                               /* invalid sequence */
			cp = term->esc.bp;
		cp++;
	}

	if (cp != term->esc.bp) { /* header only or couldn't find final char */
		/* parse DCS header */
		if (*cp == 'q')
			sixel_parse_header(term, term->esc.buf + 1);
		else if (*cp == '{')
			decdld_parse_header(term, term->esc.buf + 1);
	}

	reset_esc(term);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
xorl %ecx, %ecx
cmpl $0x5c, %esi
sete %cl
notq %rcx
movb $0x0, (%rax,%rcx)
movq 0x68(%rdi), %rsi
movq 0x70(%rdi), %rax
incq %rsi
movq %rsi, %rcx
cmpq %rax, %rsi
jae 0x7046
movq %rsi, %rcx
movzbl (%rcx), %edx
cmpl $0x3b, %edx
je 0x703e
cmpl $0x71, %edx
je 0x7046
cmpl $0x7b, %edx
je 0x7046
addb $-0x30, %dl
cmpb $0xa, %dl
jb 0x703e
movq %rax, %rcx
incq %rcx
cmpq %rax, %rcx
jb 0x7021
cmpq %rax, %rcx
je 0x706a
movzbl (%rcx), %eax
cmpl $0x7b, %eax
je 0x7062
cmpl $0x71, %eax
jne 0x706a
movq %rbx, %rdi
callq 0x69a6
jmp 0x706a
movq %rbx, %rdi
callq 0x6b40
movq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
jle 0x7344
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
leaq 0xe7e(%rip), %r13       # 0x80b0
movl 0x7c(%r14), %eax
cmpq $0x8, %rax
ja 0x732a
movzbl (%rbx,%r12), %ebp
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x0, 0x58(%r14)
jle 0x727e
cmpb $-0x40, %bpl
jl 0x727e
movq %r14, %rdi
movl $0x3f, %esi
callq 0x414e
movl $0x0, 0x5c(%r14)
movq $0x0, 0x54(%r14)
movb $0x1, 0x60(%r14)
cmpb $0x1f, %bpl
ja 0x7314
movq 0x70(%r14), %rax
movb $0x0, (%rax)
movl %ebp, %eax
leaq 0x4ef48(%rip), %rcx     # 0x561e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x732a
movq %r14, %rdi
callq *%rax
jmp 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x4281
testb %al, %al
je 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x6d9d
jmp 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x4281
testb %al, %al
je 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x6d3c
jmp 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x4281
testb %al, %al
je 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x6f18
jmp 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x4281
testb %al, %al
je 0x732a
movq %r14, %rdi
movl %ebp, %esi
callq 0x6ff4
jmp 0x732a
movq %r14, %rdi
movl %ebp, %esi
testb %bpl, %bpl
js 0x7325
callq 0x414e
jmp 0x732a
callq 0x707b
incq %r12
cmpq %r12, %r15
jne 0x7232
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0xa, %edi
je 0x73b3
cmpl $0xc, %edi
je 0x7365
cmpl $0x11, %edi
jne 0x73b2
movl $0x0, 0x4f78a(%rip)     # 0x56ae8
xorl %edi, %edi
jmp 0x2310
pushq %rbx
subq $0x80, %rsp
movl $0x0, 0x4ee49(%rip)     # 0x561c0
movl $0x5605, %esi           # imm = 0x5605
xorl %edi, %edi
movl $0x1, %edx
xorl %eax, %eax
callq 0x2140
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x21c0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2290
movq %rbx, %rdi
callq 0x2210
addq $0x80, %rsp
popq %rbx
retq
movl $0x1, %eax
movl %eax, 0x4ee02(%rip)     # 0x561c0
movl %eax, 0x4f720(%rip)     # 0x56ae4
movl $0x5605, %esi           # imm = 0x5605
xorl %edi, %edi
movl $0x2, %edx
xorl %eax, %eax
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
leaq -0x103(%rip), %rax      # 0x7345
movq %rax, -0x8(%r14)
movl $0x10000000, 0x80(%r14) # imm = 0x10000000
leaq 0x40(%rsp), %r14
movl $0x11, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2955
movl $0xa, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2955
movl $0xc, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2955
movq %rsp, %rdx
movw $0x1, (%rdx)
movl $0xa000c, 0x2(%rdx)     # imm = 0xA000C
movw $0x0, 0x6(%rdx)
movl $0x5602, %esi           # imm = 0x5602
xorl %edi, %edi
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
je 0x74c3
leaq 0x4b79f(%rip), %rsi     # 0x52c56
movl $0x1, %edi
xorl %eax, %eax
callq 0x245c
movl $0x4b3a, %esi           # imm = 0x4B3A
xorl %edi, %edi
movl $0x1, %edx
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
je 0x74ed
leaq 0x4b7ab(%rip), %rsi     # 0x52c8c
movl $0x1, %edi
xorl %eax, %eax
callq 0x245c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x29b0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movups %xmm3, 0x2c(%rdx)
movaps %xmm2, 0x20(%rdx)
movq $0x0, (%rdx)
orb $0x30, 0x8(%rdx)
andb $-0xc, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %edi, %edi
movl $0x2, %esi
callq 0x29fc
leaq 0x4b781(%rip), %rsi     # 0x52cc1
movl $0x6, %edx
xorl %edi, %edi
callq 0x286e
movb $0x1, %al
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl $0x11, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2090
movl $0xa, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2090
movl $0xc, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2090
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl $0x5602, %esi           # imm = 0x5602
xorl %edi, %edi
xorl %eax, %eax
callq 0x2140
movl $0x4b3a, %esi           # imm = 0x4B3A
xorl %edi, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2140
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x2260
movq 0x4e9f1(%rip), %rax     # 0x55fd8
movq (%rax), %rdi
callq 0x2200
leaq 0x4b6d2(%rip), %rsi     # 0x52cc8
movl $0x6, %edx
xorl %edi, %edi
callq 0x286e
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsp, %rax
movw %cx, (%rax)
movw %r8w, 0x2(%rax)
shll $0x3, %r8d
movw %r8w, 0x4(%rax)
shll $0x4, %ecx
movw %cx, 0x6(%rax)
xorl %edx, %edx
movq %rax, %rcx
callq 0x2b2a
testl %eax, %eax
je 0x764b
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4eb76(%rip), %rsi     # 0x561c8
leaq 0x4b676(%rip), %rdi     # 0x52ccf
movl $0x1, %edx
callq 0x2c13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c70
movl $0x1, %edi
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
cmpb $0x2f, -0x1(%rbx,%rax)
jne 0x1750
movb $0x0, -0x1(%rbx,%rax)
movq %rbx, %rdi
callq 0x1060
movslq %eax, %r14
cmpb $0x2f, (%rbx,%r14)
jne 0x1766
xorl %edi, %edi
jmp 0x1783
cltq
xorl %edi, %edi
cmpl $0xff, %edi
je 0x179e
leaq -0x1(%rax), %r14
incq %rdi
cmpb $0x2f, -0x1(%rbx,%rax)
movq %r14, %rax
jne 0x176a
callq 0x10c0
leaq (%rbx,%r14), %rsi
incq %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1050
callq 0x1175
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movzbl 0x10(%rdi), %esi
leaq 0x1b8f(%rip), %rdi      # 0x405e
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x186d
leaq 0x1b8e(%rip), %rdi      # 0x4073
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x1846
leaq 0x1b8b(%rip), %rdi      # 0x4088
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movl 0x14(%rbx), %esi
leaq 0x1b8d(%rip), %rdi      # 0x409d
xorl %eax, %eax
callq 0x1070
movl 0x18(%rbx), %esi
leaq 0x1b91(%rip), %rdi      # 0x40b2
xorl %eax, %eax
popq %rbx
jmp 0x1070
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x24(%rdi), %esi
callq 0x2d33
movl 0x20(%rbx), %esi
movq %rbx, %rdi
callq 0x2d33
movl 0x1c(%rbx), %esi
movq %rbx, %rdi
callq 0x2d33
movl 0x24(%rbx), %ebp
movl 0x1c(%rbx), %eax
movl %eax, %edx
xorl %ebp, %edx
movq (%rbx), %rcx
movb 0x1(%rcx), %cl
shrl %cl, %edx
movl %ebp, %esi
subl %eax, %esi
jae 0x2ca9
testl %edx, %edx
je 0x2cd6
movl 0x20(%rbx), %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl %edx, %esi
jb 0x2cf5
movl 0x28(%rbx), %esi
cmpl $-0x1, %esi
je 0x2cd1
subl %ecx, %ebp
movl %esi, %r14d
subl %ecx, %r14d
movq %rbx, %rdi
callq 0x2d33
cmpl %ebp, %r14d
jae 0x2d14
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x195d(%rip), %rdi      # 0x463a
leaq 0x196e(%rip), %rsi      # 0x4652
leaq 0x1976(%rip), %rcx      # 0x4661
movl $0x2d, %edx
callq 0x1080
leaq 0x198b(%rip), %rdi      # 0x4687
leaq 0x194f(%rip), %rsi      # 0x4652
leaq 0x1957(%rip), %rcx      # 0x4661
movl $0x33, %edx
callq 0x1080
leaq 0x19a1(%rip), %rdi      # 0x46bc
leaq 0x1930(%rip), %rsi      # 0x4652
leaq 0x1938(%rip), %rcx      # 0x4661
movl $0x3d, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
testl %edx, %edx
jns 0x2dbc
movq (%r15), %rax
movl 0x4(%rax), %ebx
movb 0x1(%rax), %cl
shll %cl, %ebx
testl %ebx, %ebx
jle 0x2e35
xorl %r12d, %r12d
leaq 0xc(%rsp), %r13
leal (%r14,%r12), %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x2e8b
testl %eax, %eax
jns 0x2df2
movl 0xc(%rsp), %esi
cmpl $0x5, %esi
je 0x2e38
leaq 0x18e6(%rip), %rdi      # 0x46d3
callq 0x2c09
movq %r15, %rdi
callq 0x186d
cmpl %r12d, %eax
jb 0x2e6c
movl 0x28(%r15), %esi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
callq 0x18a9
testl %eax, %eax
jns 0x2e27
movl 0xc(%rsp), %esi
leaq 0x190e(%rip), %rdi      # 0x4730
callq 0x2c09
cmpl 0x10(%rsp), %ebp
jne 0x2e4d
incl %r12d
cmpl %r12d, %ebx
jne 0x2dc8
movl %ebx, %r12d
movl %r12d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18e6(%rip), %rdi      # 0x473a
leaq 0x17f7(%rip), %rsi      # 0x4652
leaq 0x1894(%rip), %rcx      # 0x46f6
movl $0x9f, %edx
callq 0x1080
leaq 0x1868(%rip), %rdi      # 0x46db
leaq 0x17d8(%rip), %rsi      # 0x4652
leaq 0x1875(%rip), %rcx      # 0x46f6
movl $0x9a, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %r14
movq (%rdi), %rax
movb (%rax), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rdx, -0x40(%rbp)
movl %esi, %ebx
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, %rsp
movslq %eax, %rdx
movl %ebx, %edi
movq %rsi, -0x48(%rbp)
callq 0x2b74
leaq -0xd0(%rbp), %rax
movl %ebx, (%rax)
leaq -0x2c(%rbp), %r12
leaq -0x160(%rbp), %r15
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2c68
movq %r14, %rdi
movq -0x48(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1a6b
testl %eax, %eax
je 0x302b
movl -0x34(%rbp), %eax
cmpl $0x4, %eax
jne 0x3019
movl %ebx, -0x30(%rbp)
leaq 0x1954(%rip), %rdi      # 0x487b
callq 0x1060
testb $0x4, 0x12(%r14)
je 0x2ff2
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1f38
movl %eax, %r13d
movq %r14, %rdi
callq 0x2c68
movq %r14, %rdi
cmpl $-0x1, %r13d
je 0x2f89
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x18a9
testl %eax, %eax
jns 0x2f76
movl -0x2c(%rbp), %esi
leaq 0x17bf(%rip), %rdi      # 0x4730
callq 0x2c09
movq %r14, %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1eaa
jmp 0x2f95
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a6b
movl %eax, %r13d
movq %r14, %rdi
callq 0x2c68
testl %r13d, %r13d
jns 0x2fe1
movl -0x2c(%rbp), %esi
cmpl $0x4, %esi
jne 0x2fd5
leaq 0x18f0(%rip), %rdi      # 0x48a4
callq 0x1060
leal 0x1(%rbx), %r13d
cmpl $0x7, %ebx
jl 0x2fe4
leaq 0x18a5(%rip), %rdi      # 0x486e
movl $0x3, %esi
callq 0x2c09
jmp 0x2fe4
leaq 0x189a(%rip), %rdi      # 0x4876
callq 0x2c09
movl %ebx, %r13d
testb $0x4, 0x12(%r14)
movl %r13d, %ebx
jne 0x2f39
movq %r14, %rdi
callq 0x2c68
leaq 0x188d(%rip), %rdi      # 0x488e
callq 0x1060
movl -0x30(%rbp), %ebx
incl %ebx
cmpl $0x8, %ebx
jne 0x2eea
movl $0x3, %eax
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x3024
movl %eax, (%rcx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x302d
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4389
movq 0x8(%rbx), %rdi
leaq 0x53(%rip), %r14        # 0x4395
movq %r14, %rsi
callq 0x2db5
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2db5
movq 0x8(%rbx), %rdi
callq 0x2bce
movq 0x10(%rbx), %rdi
callq 0x2bce
movq (%rbx), %rdi
callq 0x32be
movq 0x28(%rbx), %rdi
leaq 0x434d(%rip), %rsi      # 0x86c8
callq 0x2db5
movq 0x28(%rbx), %rdi
callq 0x2bce
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x43c4
cmpl $0x2d, 0x8(%rbx)
jne 0x43bb
movq 0x20(%rbx), %rdi
callq 0x7b74
movq 0x38(%rbx), %rdi
callq 0x3bba
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x38ba
cmpl $0x70, %eax
jne 0x4415
leaq 0x6c71(%rip), %rsi      # 0xb076
xorl %ebx, %ebx
xorl %edi, %edi
xorl %eax, %eax
callq 0x22f9
jmp 0x44f9
leaq 0x473(%rip), %r12       # 0x488f
movq (%rbx), %rdi
callq 0x330e
movq %rax, %r14
movb $0x1, %r13b
addl $-0x40, %eax
movq %r12, %r15
cmpl $0x2, %eax
jb 0x444c
leal -0x42(%r14), %eax
cmpl $0x1, %eax
ja 0x450a
xorl %r13d, %r13d
leaq 0x7bf(%rip), %r15       # 0x4c0b
movq (%rbx), %rdi
callq 0x330e
cmpq $0x32, %rax
jne 0x4499
movq %rbx, %rdi
movl %r14d, %esi
callq *%r15
cmpl $-0x1, %eax
je 0x44f4
movq (%rbx), %rdi
callq 0x330e
cmpq $0x33, %rax
jne 0x44a0
movq (%rbx), %rdi
callq 0x330e
cmpq $0x30, %rax
jne 0x44a7
movq (%rbx), %rdi
callq 0x38ba
cmpl $0x70, %eax
jne 0x441c
xorl %ebx, %ebx
jmp 0x44f9
movl $0x7b, %edx
jmp 0x44ac
movl $0x7d, %edx
jmp 0x44ac
movl $0x3b, %edx
movq (%rbx), %rax
cmpl $0x41, %r14d
leaq 0x67e4(%rip), %rcx      # 0xac9e
leaq 0x67d7(%rip), %rsi      # 0xac98
cmoveq %rcx, %rsi
cmpl $0x43, %r14d
leaq 0x67de(%rip), %rdi      # 0xacae
leaq 0x67ce(%rip), %rcx      # 0xaca5
cmoveq %rdi, %rcx
movslq 0x28(%rax), %rdi
testb %r13b, %r13b
cmovneq %rsi, %rcx
leaq 0x6c1d(%rip), %rsi      # 0xb10a
xorl %eax, %eax
callq 0x3f64
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x6bdb(%rip), %rsi      # 0xb0f3
xorl %eax, %eax
callq 0x3f64
jmp 0x44f4
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edi, %r14d
movl $0x40, %edi
callq 0x3a4e
movq %rax, %rbx
testq %rax, %rax
je 0x4577
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl %r14d, %edi
callq 0x3258
movq %rax, (%rbx)
callq 0x2b2c
movq %rax, 0x8(%rbx)
callq 0x2b2c
movq %rax, 0x10(%rbx)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x1c(%rbx)
movq %rbx, %rdi
callq 0x43e0
cmpl $-0x1, %eax
jne 0x458e
movq %rbx, %rdi
callq 0x4328
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: print_token_entry
void
print_token_entry(lexical_spec_t* spec) {
    for (size_t i = 0; i < SIZE_VECTOR(spec->entry_vect); ++i) {
        spec_entry_t* crt_entry = AT_VECTOR(spec->entry_vect, i);
        printf("Token %s, fragment %d.\n",
                                        crt_entry->name, crt_entry->fragment);
        printf("Root node = %p\n", crt_entry->regex_ast);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x4880
movq %rdi, %rbx
leaq 0x688a(%rip), %r14      # 0xb0cb
leaq 0x689b(%rip), %r15      # 0xb0e3
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movq 0x10(%r13), %rsi
movzbl 0x18(%r13), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movq 0x20(%r13), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
incq %r12
movq 0x8(%rbx), %rax
cmpq 0x10(%rax), %r12
jb 0x484b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_action_state
int
spec_action_state(lexical_spec_t* spec, spec_entry_t* entry) {
    if (advance_token(spec->lex) != T_LPAREN) {
        errorf(CURRENT_LINE(spec->lex),
                        "Missing an open paren in the action list construct.");
        return (ERROR);
    }
    
    size_t count_pos = 0;
    if (spec_action_pair(spec, entry, &count_pos) == ERROR)
        { return (ERROR); }

    while (peek_token(spec->lex) == T_COMMA) {
        advance_token(spec->lex);
        if (peek_token(spec->lex) == T_RPAREN)
            { break; }
        else if (spec_action_pair(spec, entry, &count_pos) == ERROR)
            { return (ERROR); }
    }

    if (advance_token(spec->lex) != T_RPAREN) {
        errorf(CURRENT_LINE(spec->lex),
                    "Missing a close paren in the action list construct.");
        return (ERROR);
    }
    return (DONE);  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x330e
cmpq $0x34, %rax
jne 0x4f71
leaq -0x28(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4fbd
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x4f8c
leaq -0x28(%rbp), %r12
movq (%rbx), %rdi
callq 0x38ba
cmpl $0x31, %eax
jne 0x4f9c
movq (%rbx), %rdi
callq 0x330e
movq (%rbx), %rdi
callq 0x38ba
cmpl $0x35, %eax
je 0x4f9c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4fbd
cmpl $-0x1, %eax
jne 0x4f3a
jmp 0x4f8c
movq (%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x6404(%rip), %rsi      # 0xb383
xorl %eax, %eax
callq 0x3f64
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x330e
xorl %r15d, %r15d
cmpq $0x35, %rax
je 0x4f8c
movq (%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x63fc(%rip), %rsi      # 0xb3b7
jmp 0x4f7f
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_record
void
del_nfa_record(void) {
    foreach_vector(record_nfa_state, &del_nfa_state);
    del_vector(record_nfa_state);
    foreach_vector(record_nfa_automata, &del_nfa_automaton);
    del_vector(record_nfa_automata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18a9d(%rip), %rdi     # 0x1deb0
leaq 0x31(%rip), %rsi        # 0x544b
callq 0x2db5
movq 0x18a8a(%rip), %rdi     # 0x1deb0
callq 0x2bce
movq 0x18a86(%rip), %rdi     # 0x1deb8
leaq 0x46(%rip), %rsi        # 0x547f
callq 0x2db5
movq 0x18a73(%rip), %rdi     # 0x1deb8
popq %rbp
jmp 0x2bce
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: del_nfa_state
static void
del_nfa_state(nfa_state_t* state) {
    if (state) {
        if (state->symbol_edge == EDGE_CLASS)
            { del_bitset(state->class); }
        del_bitset(state->eclos);
    }
    FREE(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5471
cmpl $-0x2, 0x10(%rbx)
jne 0x5468
movq 0x28(%rbx), %rdi
callq 0x24c6
movq 0x30(%rbx), %rdi
callq 0x24c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_union
static nfa_automaton_t*
regex_node_union(regex_node_t* root) {
    nfa_automaton_t* left = dfs_regex_node(root->left);
    if (!left)
        { return (NULL_AUTOMATON); }

    nfa_automaton_t* right = dfs_regex_node(root->right);
    if (!right) {
        del_nfa_automaton(left);
        return (NULL_AUTOMATON);
    }

    nfa_state_t* new_tail_state = new_nfa_state(EDGE_AUTOMATA, left, right);
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);

    if ((!new_tail_state) || (!new_head_state)) {
        del_nfa_automaton(left);
        del_nfa_automaton(right);
        return (NULL_AUTOMATON);
    }

    if (left->head_state->symbol_edge == NO_EDGE)
        { left->head_state->symbol_edge = EPSILON; }
    else
        { left->head_state->symbol_edge = EDGE_BOTH; }
    left->head_state->out_state = new_head_state; 

    if (right->head_state->symbol_edge == NO_EDGE)
        { right->head_state->symbol_edge = EPSILON; } 
    else
        { right->head_state->symbol_edge = EDGE_BOTH; }
    right->head_state->out_state = new_head_state;   

    return (new_nfa_automaton(NFA_UNION,
                                left, right, new_tail_state, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x5b26
testq %rax, %rax
je 0x5f2c
movq %rax, %rbx
movq 0x18(%r14), %rdi
callq 0x5b26
testq %rax, %rax
je 0x5f17
movq %rax, %r14
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x54aa
movq %rax, %r15
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
xorl %eax, %eax
callq 0x54aa
testq %r15, %r15
setne %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x5f1c
movq 0x28(%rbx), %rcx
cmpl $-0x4, 0x10(%rcx)
movl $0x101, %edx            # imm = 0x101
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
cmovel %edx, %esi
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
movl %esi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movq 0x28(%r14), %rcx
cmpl $-0x4, 0x10(%rcx)
cmovel %edx, %edi
movl %edi, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x58d4
movq %rbx, %rdi
jmp 0x5f27
movq %rbx, %rdi
callq 0x547f
movq %r14, %rdi
callq 0x547f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_concat
static nfa_automaton_t*
regex_node_concat(regex_node_t* root) {
    nfa_automaton_t* left = dfs_regex_node(root->left);
    if (!left)
        { return (NULL_AUTOMATON); }

    size_t start_state = SIZE_VECTOR(record_nfa_state);

    nfa_automaton_t* right = dfs_regex_node(root->right);
    if (!right) {
        del_nfa_automaton(left);
        return (NULL_AUTOMATON);
    }
    else if (IS_LOOK(root)) {
        for (size_t i = start_state; i < SIZE_VECTOR(record_nfa_state); ++i) {
            nfa_state_t* crt_state = (nfa_state_t*)
                                        AT_VECTOR(record_nfa_state, i);
            crt_state->in_look_machine = true;
        }
    }

    if (left->head_state->symbol_edge != EDGE_AUTOMATA) {
        left->head_state->symbol_edge = EDGE_AUTOMATA;
        left->head_state->edge = right;
    }
    else
        { left->head_state->edge2 = right; }

    if (root->kind_ast == AST_LOOK)
        { set_states_lookahead(right); }

    return (new_nfa_automaton(NFA_CONCAT, left, right, right->head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0x5b26
testq %rax, %rax
je 0x5fbe
movq %rax, %rbx
movq 0x17f51(%rip), %rax     # 0x1deb0
movq 0x10(%rax), %r12
movq 0x18(%r15), %rdi
callq 0x5b26
testq %rax, %rax
je 0x5fb6
movq %rax, %r14
movl (%r15), %eax
cmpl $0x5, %eax
jne 0x5f9f
movq 0x17f2d(%rip), %rdx     # 0x1deb0
movq 0x10(%rdx), %rcx
cmpq %rcx, %r12
jae 0x5f9f
movq (%rdx), %rdx
movq (%rdx,%r12,8), %rsi
movb $0x1, 0xe(%rsi)
incq %r12
cmpq %r12, %rcx
jne 0x5f8f
movq 0x28(%rbx), %rcx
cmpl $-0x1, 0x10(%rcx)
je 0x5fc9
movl $0xffffffff, 0x10(%rcx) # imm = 0xFFFFFFFF
movq %r14, 0x20(%rcx)
jmp 0x5fd0
movq %rbx, %rdi
callq 0x547f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x28(%rcx)
movl (%r15), %eax
cmpl $0x5, %eax
jne 0x5fdd
movq %r14, %rdi
callq 0x605d
movq 0x28(%r14), %rcx
movl $0x2, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x58d4
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: regex_node_class
static nfa_automaton_t*
regex_node_class(bitset_t* root_class) {
    nfa_state_t* new_head_state = new_nfa_state(NO_EDGE);
    if (!new_head_state)
        { return (NULL_AUTOMATON); }

    nfa_state_t* new_tail_state = new_nfa_state(EDGE_CLASS,
                                    dup_bitset(root_class), new_head_state);
    if (!new_tail_state) {
        del_nfa_state(new_head_state);
        return (NULL_AUTOMATON);
    }
    
    return (new_nfa_automaton(NFA_CLASS, new_tail_state, new_head_state));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0xfffffffc, %edi       # imm = 0xFFFFFFFC
xorl %eax, %eax
callq 0x54aa
testq %rax, %rax
je 0x6056
movq %rax, %rbx
movq %r14, %rdi
callq 0x24f4
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x54aa
testq %rax, %rax
je 0x604e
movl $0x6, %edi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x58d4
movq %rbx, %rdi
callq 0x544b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/nfa.c
// Function: set_states_lookahead
static bool
set_states_lookahead(nfa_automaton_t* right) {
    switch (right->kind_nfa) {
        case NFA_UNION: ;
            bool once_false = true;
            once_false = set_states_lookahead(right->right);
            if (!set_states_lookahead(right->left))
                { once_false = false; }
            return (once_false);

        case NFA_CONCAT:
            if (!set_states_lookahead(right->left)
                                && !set_states_lookahead(right->right))
                { return (false); }
            break;

        case NFA_CLOSURE:
            set_states_lookahead(right->middle);
            return (false);
 
        case NFA_CLASS:
        case NFA_SYMBOL:
            right->head_state->beg_lookahead = true;
            break;

        case NFA_EPSILON:
            return (false);

        default:
            break;
    }
    return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movb $0x1, %bl
movl 0x8(%r14), %eax
cmpl $0x1, %eax
jne 0x607d
movq 0x10(%r14), %r14
xorl %ebx, %ebx
jmp 0x606c
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x609d
leaq 0x5870(%rip), %rcx      # 0xb8fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%r14), %rax
movb $0x1, 0xd(%rax)
movb $0x1, %al
jmp 0x60bf
xorl %eax, %eax
jmp 0x60bf
movq 0x18(%r14), %rdi
callq 0x605d
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x60bf
movq 0x20(%r14), %rdi
callq 0x605d
andb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%r14), %rdi
callq 0x605d
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x605d
andb %al, %bl
andb %r15b, %bl
jmp 0x60c1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: build_regex
regex_node_t*
build_regex(lexical_spec_t* spec, spec_entry_t* entry) {
    regex_spec = spec;
    regex_entry = entry;
    if (peek_token(spec->lex) == T_REG_CARET) {
        advance_token(spec->lex);
        entry->beg_line = true;
    }
    regex_node_t* root = regex_look();
    if (!root)
        { return (NULL_NODE); }
    if (peek_token(spec->lex) == T_REG_DOLLAR) {
        if (root->kind_ast == AST_LOOK) {
            del_regex_node(root);
            errorf(CURRENT_LINE(regex_spec->lex),
                                "$ can't follow the / operator.");
            return (NULL_NODE);
        }
        advance_token(spec->lex);
        root = new_regex_node(AST_LOOK, root,
                                    new_regex_node(AST_SYMBOL, '\n', false));
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x17dbc(%rip)     # 0x1dec0
movq %rsi, 0x17dbd(%rip)     # 0x1dec8
movq (%rdi), %rdi
callq 0x38ba
cmpl $0x18, %eax
jne 0x6124
movq (%r14), %rdi
callq 0x330e
movb $0x1, 0x19(%rbx)
callq 0x6207
testq %rax, %rax
je 0x61c1
movq %rax, %rbx
movq 0x17d84(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x38ba
cmpl $0xb, %eax
jne 0x6187
movq 0x17d70(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x330e
callq 0x6207
testq %rax, %rax
je 0x61c5
movl $0x5, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x77d0
movq %rax, %rbx
movq 0x17d4a(%rip), %rax     # 0x1dec8
movb $0x1, 0x1a(%rax)
testq %rbx, %rbx
je 0x61c1
movq (%r14), %rdi
callq 0x38ba
cmpl $0x19, %eax
jne 0x61ce
cmpl $0x5, (%rbx)
jne 0x61d6
movq %rbx, %rdi
callq 0x7b74
movq 0x17d18(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x585a(%rip), %rsi      # 0xba10
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3f64
jmp 0x61ce
xorl %ebx, %ebx
jmp 0x61ce
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x7b74
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
callq 0x330e
movl $0xa, %edi
movl $0xa, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x77d0
movl $0x5, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x77d0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_union
static regex_node_t*
regex_union(void) {
    regex_node_t* root = regex_cat();
    if (!root)
        { return (NULL_NODE); }

    while (peek_token(regex_spec->lex) == T_REG_UNION) {
        advance_token(regex_spec->lex);
        regex_node_t* right_op = regex_cat();
        if (!right_op) {
            del_regex_node(root);
            errorf(CURRENT_LINE(regex_spec->lex), "Missing an operand to '|'.");
            return (NULL_NODE);
        }
        root = new_regex_node(AST_UNION, root, right_op);
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x628c
testq %rax, %rax
je 0x6258
movq %rax, %rbx
movq 0x17c9f(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x38ba
cmpl $0x4, %eax
jne 0x6282
movq 0x17c8b(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
callq 0x330e
callq 0x628c
testq %rax, %rax
je 0x625c
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x77d0
jmp 0x6217
xorl %ebx, %ebx
jmp 0x6282
movq %rbx, %rdi
callq 0x7b74
movq 0x17c55(%rip), %rax     # 0x1dec0
movq (%rax), %rax
movslq 0x28(%rax), %rdi
leaq 0x57b6(%rip), %rsi      # 0xba2f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3f64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfl/src/regex.c
// Function: regex_cat
static regex_node_t*
regex_cat(void) {
    regex_node_t* root = regex_closure();
    if (!root)
        { return (NULL_NODE); }

    while (!in_first(regex_spec->lex, T_REG_LOOK, T_REG_UNION, T_REG_RPAREN,
                                    T_REG_DOLLAR, T_CLOSE_REGEX, T_EOF, -1)) {
         regex_node_t* right_op = regex_closure();
        if (!right_op) {
            del_regex_node(root);
            return (NULL_NODE); 
        }
        root = new_regex_node(AST_CONCAT, root, right_op);
    }
    return (root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x6309
testq %rax, %rax
je 0x62fd
movq %rax, %rbx
movq 0x17c1a(%rip), %rax     # 0x1dec0
movq (%rax), %rdi
movl $0xb, %esi
movl $0x4, %edx
movl $0x9, %ecx
movl $0x19, %r8d
movl $0x3, %r9d
xorl %eax, %eax
pushq $-0x1
pushq $0x70
callq 0x38e8
addq $0x10, %rsp
testb %al, %al
jne 0x62ff
callq 0x6309
testq %rax, %rax
je 0x62f5
movl $0x1, %edi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x77d0
jmp 0x629c
movq %rbx, %rdi
callq 0x7b74
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq