LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/uobikiemukot[P]yaft/./ctrlseq/dcs.h
// Function: sixel_parse_header
void sixel_parse_header(struct terminal_t *term, char *start_buf)
{
	/*
	sixel format
		DSC P1; P2; P3; q; s...s; ST
	parameters
		DCS: ESC(0x1B) P (0x50) (8bit C1 character not recognized)
		P1 : pixel aspect ratio (force 0, 2:1) (ignored)
		P2 : background mode (ignored)
			0 or 2: 0 stdands for current background color (default)
			1     : 0 stands for remaining current color
		P3 : horizontal grid parameter (ignored)
		q  : final character of sixel sequence
		s  : see parse_sixel_data()
		ST : ESC (0x1B) '\' (0x5C) or BEL (0x07)
	*/
	char *cp;
	struct parm_t parm;

	/* replace final char of sixel header by NUL '\0' */
	cp = strchr(start_buf, 'q');
	*cp = '\0';

	logging(DEBUG, "sixel_parse_header()\nbuf:%s\n", start_buf);

	/* split header by semicolon ';' */
	reset_parm(&parm);
	parse_arg(start_buf, &parm, ';', isdigit);

	/* set canvas parameters */
	reset_sixel(&term->sixel, term->color_pair, term->width, term->height);
	sixel_parse_data(term, &term->sixel, cp + 1); /* skip 'q' */
	sixel_copy2cell(term, &term->sixel);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x71, %esi
callq 0x2100
movq %rax, %r14
movb $0x0, (%rax)
movl $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rsp)
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x10(%rsp)
testq %r15, %r15
je 0x6a7c
movq %r15, %rdi
callq 0x20d0
testq %rax, %rax
je 0x6a7c
movl 0x8(%rsp), %ecx
xorl %edx, %edx
testq %rdx, %rdx
jne 0x6a23
movsbl (%r15), %edx
addl $-0x3a, %edx
cmpl $-0xa, %edx
movl $0x0, %edx
cmovaeq %r15, %rdx
cmpb $0x3b, (%r15)
jne 0x6a3e
movb $0x0, (%r15)
cmpl $0xf, %ecx
jg 0x6a3c
movslq %ecx, %rsi
movq %rdx, 0x10(%rsp,%rsi,8)
incl %ecx
xorl %edx, %edx
cmpq $0x1, %rax
jne 0x6a58
testq %rdx, %rdx
je 0x6a62
cmpl $0xf, %ecx
jg 0x6a58
movslq %ecx, %rsi
movq %rdx, 0x10(%rsp,%rsi,8)
incl %ecx
incq %r15
decq %rax
jne 0x6a0b
jmp 0x6a78
cmpb $0x0, (%r15)
setne %sil
cmpl $0x10, %ecx
setge %dil
orb %sil, %dil
je 0x6a4e
jmp 0x6a58
movl %ecx, 0x8(%rsp)
leaq 0xbb588(%rbx), %r15
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %ecx
movl 0x4c(%rbx), %esi
movq %r15, %rdi
callq 0x6714
incq %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5eb1
movq %rbx, %rdi
movq %r15, %rsi
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x67f6
// File: /workspace/github_c_makefile_star2_O1/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 0x6bcc
addq %r14, %rax
leaq 0x6(%rbx), %rdx
xorl %edi, %edi
xorl %esi, %esi
movzbl (%r14), %r8d
leal -0x7f(%r8), %ecx
cmpb $-0x40, %cl
jae 0x6b33
cmpl $0x2f, %r8d
je 0x6bbb
cmpl $0x3b, %r8d
je 0x6b96
testl %r8d, %r8d
jne 0x6bc0
jmp 0x6bcc
cmpb $0x7, %dil
ja 0x6b91
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 0x6b88
leaq (%r9,%r11), %r15
cmpq $0xf, %r15
ja 0x6b88
orw %r10w, (%rcx,%r11,2)
incq %r11
cmpq $0x6, %r11
jne 0x6b73
incb %dil
jmp 0x6bc0
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 0x6bbe
incb %sil
xorl %edi, %edi
incq %r14
cmpq %rax, %r14
jb 0x6b08
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e04
leaq 0x4f4ea(%rip), %rax     # 0x562e0
movq (%rax,%r14,8), %rax
testq %rax, %rax
je 0x6e04
movq %rbx, %rdi
callq *%rax
addl $-0x50, %r14d
cmpl $0xd, %r14d
ja 0x6e19
movl $0x2801, %eax           # imm = 0x2801
btl %r14d, %eax
jb 0x6e28
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_O1/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 0x6efd
xorl %ecx, %ecx
testq %rcx, %rcx
jne 0x6ea9
movsbl (%r14), %ecx
addl $-0x3a, %ecx
cmpl $-0xa, %ecx
jb 0x6ea7
movq %r14, %rcx
jmp 0x6ea9
xorl %ecx, %ecx
cmpb $0x3b, (%r14)
jne 0x6ecc
movb $0x0, (%r14)
movslq 0x8(%rsp), %rdx
cmpq $0xf, %rdx
jg 0x6eca
movq %rcx, 0x10(%rsp,%rdx,8)
leal 0x1(%rdx), %ecx
movl %ecx, 0x8(%rsp)
xorl %ecx, %ecx
cmpq $0x1, %rax
jne 0x6ef5
testq %rcx, %rcx
je 0x6eef
movslq 0x8(%rsp), %rdx
cmpq $0xf, %rdx
jg 0x6ef5
movq %rcx, 0x10(%rsp,%rdx,8)
incl %edx
movl %edx, 0x8(%rsp)
jmp 0x6ef5
cmpb $0x0, (%r14)
je 0x6ed7
incq %r14
decq %rax
jne 0x6e91
movzbl %bpl, %eax
leaq 0x4f7d8(%rip), %rcx     # 0x566e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x6f1b
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_O1/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       # 0x6f36
movq %r14, %rsi
movl $0x3b, %edx
callq 0x2db0
cmpl $0x0, (%r14)
jle 0x7057
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7013
xorl %esi, %esi
movl $0xa, %edx
callq 0x2d03
movq %rax, %r14
jmp 0x7016
xorl %r14d, %r14d
cmpl $0x22c4, %r14d          # imm = 0x22C4
je 0x704c
cmpl $0x68, %r14d
je 0x7038
cmpl $0x4, %r14d
jne 0x7057
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5a33
jmp 0x7043
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5b5b
cmpl $0x22c4, %r14d          # imm = 0x22C4
jne 0x7057
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5bee
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_O1/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), %rcx
leaq 0x1(%rsi), %rax
cmpq %rcx, %rax
jae 0x70bb
movzbl (%rax), %edx
cmpl $0x3b, %edx
je 0x70b6
cmpl $0x71, %edx
je 0x70bb
cmpl $0x7b, %edx
je 0x70bb
addb $-0x30, %dl
cmpb $0xa, %dl
jb 0x70b6
movq %rcx, %rax
incq %rax
jmp 0x7094
cmpq %rcx, %rax
je 0x70e5
movzbl (%rax), %eax
cmpl $0x7b, %eax
je 0x70da
cmpl $0x71, %eax
jne 0x70e5
incq %rsi
movq %rbx, %rdi
callq 0x6994
jmp 0x70e5
incq %rsi
movq %rbx, %rdi
callq 0x6bd7
movq 0x68(%rbx), %rax
movq %rax, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7449
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 0xd59(%rip), %r13       # 0x8090
movl 0x7c(%r14), %eax
cmpq $0x8, %rax
ja 0x742f
movzbl (%rbx,%r12), %ebp
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x0, 0x58(%r14)
jle 0x7383
cmpb $-0x40, %bpl
jl 0x7383
movq %r14, %rdi
movl $0x3f, %esi
callq 0x4116
movl $0x0, 0x5c(%r14)
movq $0x0, 0x54(%r14)
movb $0x1, 0x60(%r14)
cmpb $0x1f, %bpl
ja 0x7419
movq 0x70(%r14), %rax
movb $0x0, (%rax)
movl %ebp, %eax
leaq 0x4ee43(%rip), %rcx     # 0x561e0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x742f
movq %r14, %rdi
callq *%rax
jmp 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x4249
testb %al, %al
je 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x6e2d
jmp 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x4249
testb %al, %al
je 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x6dcc
jmp 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x4249
testb %al, %al
je 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x6f82
jmp 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x4249
testb %al, %al
je 0x742f
movq %r14, %rdi
movl %ebp, %esi
callq 0x7071
jmp 0x742f
movq %r14, %rdi
movl %ebp, %esi
testb %bpl, %bpl
js 0x742a
callq 0x4116
jmp 0x742f
callq 0x70f6
incq %r12
cmpq %r12, %r15
jne 0x7337
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74b8
cmpl $0xc, %edi
je 0x746a
cmpl $0x11, %edi
jne 0x74b7
movl $0x0, 0x4f685(%rip)     # 0x56ae8
xorl %edi, %edi
jmp 0x2310
pushq %rbx
subq $0x80, %rsp
movl $0x0, 0x4ed44(%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, 0x4ecfd(%rip)     # 0x561c0
movl %eax, 0x4f61b(%rip)     # 0x56ae4
movl $0x5605, %esi           # imm = 0x5605
xorl %edi, %edi
movl $0x2, %edx
xorl %eax, %eax
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x48, %rsp
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x2c(%rsi), %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
movl $0x2, %esi
callq 0x29ed
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x40(%rsp), %r14
movl $0x98, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
leaq -0x103(%rip), %rax      # 0x744a
movq %rax, (%r14)
movl $0x10000000, 0x88(%r14) # imm = 0x10000000
movl $0x11, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2946
movl $0xa, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2946
movl $0xc, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2946
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 0x75c2
leaq 0x4b680(%rip), %rsi     # 0x52c36
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 0x75ec
leaq 0x4b68c(%rip), %rsi     # 0x52c6c
movl $0x1, %edi
xorl %eax, %eax
callq 0x245c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x29a1
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 0x29ed
leaq 0x4b662(%rip), %rsi     # 0x52ca1
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_O1/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 0x4e8f2(%rip), %rax     # 0x55fd8
movq (%rax), %rdi
callq 0x2200
leaq 0x4b5b3(%rip), %rsi     # 0x52ca8
movl $0x6, %edx
xorl %edi, %edi
callq 0x286e
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b1b
testl %eax, %eax
je 0x774a
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4ea77(%rip), %rsi     # 0x561c8
leaq 0x4b557(%rip), %rdi     # 0x52caf
movl $0x1, %edx
callq 0x2c04
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c61
movl $0x1, %edi
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O1/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:
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, %r8
movq %rdi, %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movl %edx, %edi
andl $-0x40, %edi
subl %edi, %ecx
movl $0x1, %edi
shlq %cl, %rdi
movups %xmm0, (%rsi)
movl $0x1, %r9d
sarl $0x6, %edx
movslq %edx, %rcx
orq %rdi, (%rsi,%rcx,8)
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movl %edx, %edi
andl $-0x40, %edi
movl %eax, %ecx
subl %edi, %ecx
shlq %cl, %r9
sarl $0x6, %edx
movslq %edx, %rcx
orq %r9, (%rsi,%rcx,8)
movq $0x0, (%r8)
movq $0x3a98, 0x8(%r8)       # imm = 0x3A98
incl %eax
movl %eax, %edi
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x27f7
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x10008, %rsp          # imm = 0x10008
movq %rsi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1232
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x1232
movl %eax, %r14d
orl %ebp, %r14d
movq %rsp, %r15
movl $0x10000, %edx          # imm = 0x10000
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
movq %r15, %rdx
callq 0x1232
orl %r14d, %eax
addq $0x10008, %rsp          # imm = 0x10008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xdb7(%rip), %rdi       # 0x2004
movq %r12, %rsi
xorl %eax, %eax
callq 0x1060
movq 0x2d82(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1090
movq %r14, %rdi
movq %r15, %rsi
callq 0x1030
testq %rax, %rax
je 0x1303
movq %rax, %rbx
movq %rax, %rdi
callq 0x1050
movq %rax, %r12
movq %rbx, %rdi
callq 0x10a0
movq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1080
testl %eax, %eax
jne 0x12d2
xorl %eax, %eax
cmpq %r14, %r12
setne %al
testq %r13, %r13
leal (%rax,%rax,2), %eax
movl $0x4, %ebp
cmovnel %eax, %ebp
testq %r14, %r14
cmovel %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1080
testl %eax, %eax
je 0x12d7
movl $0x5, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
testl %eax, %eax
jne 0x12f4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
testl %eax, %eax
je 0x12f9
movl $0x6, %ebp
movq %rbx, %rdi
callq 0x10c0
jmp 0x1310
movq %r12, %rdi
callq 0x10b0
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1743
movb $0x0, -0x1(%rbx,%rax)
movq %rbx, %rdi
callq 0x1060
movslq %eax, %r14
cmpb $0x2f, (%rbx,%r14)
jne 0x1759
xorl %edi, %edi
jmp 0x1776
cltq
xorl %edi, %edi
cmpl $0xff, %edi
je 0x1791
leaq -0x1(%rax), %r14
incq %rdi
cmpb $0x2f, -0x1(%rbx,%rax)
movq %r14, %rax
jne 0x175d
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_O1/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 0x1b73(%rip), %rdi      # 0x405e
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x1896
leaq 0x1b72(%rip), %rdi      # 0x4073
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x186f
leaq 0x1b6f(%rip), %rdi      # 0x4088
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movl 0x14(%rbx), %esi
leaq 0x1b71(%rip), %rdi      # 0x409d
xorl %eax, %eax
callq 0x1070
movl 0x18(%rbx), %esi
leaq 0x1b75(%rip), %rdi      # 0x40b2
xorl %eax, %eax
popq %rbx
jmp 0x1070
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2d6f
movl 0x20(%rbx), %esi
movq %rbx, %rdi
callq 0x2d6f
movl 0x1c(%rbx), %esi
movq %rbx, %rdi
callq 0x2d6f
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 0x2ce5
testl %edx, %edx
je 0x2d12
movl 0x20(%rbx), %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl %edx, %esi
jb 0x2d31
movl 0x28(%rbx), %esi
cmpl $-0x1, %esi
je 0x2d0d
subl %ecx, %ebp
movl %esi, %r14d
subl %ecx, %r14d
movq %rbx, %rdi
callq 0x2d6f
cmpl %ebp, %r14d
jae 0x2d50
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1921(%rip), %rdi      # 0x463a
leaq 0x1932(%rip), %rsi      # 0x4652
leaq 0x193a(%rip), %rcx      # 0x4661
movl $0x2d, %edx
callq 0x1080
leaq 0x194f(%rip), %rdi      # 0x4687
leaq 0x1913(%rip), %rsi      # 0x4652
leaq 0x191b(%rip), %rcx      # 0x4661
movl $0x33, %edx
callq 0x1080
leaq 0x1965(%rip), %rdi      # 0x46bc
leaq 0x18f4(%rip), %rsi      # 0x4652
leaq 0x18fc(%rip), %rcx      # 0x4661
movl $0x3d, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x2df8
movq (%r15), %rax
movl 0x4(%rax), %ebx
movb 0x1(%rax), %cl
shll %cl, %ebx
testl %ebx, %ebx
jle 0x2e87
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
leal (%r14,%rbp), %r13d
movq %r15, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0x2ed9
testl %eax, %eax
jns 0x2e3a
movl 0x8(%rsp), %esi
cmpl $0x5, %esi
jne 0x2e2e
xorl %eax, %eax
movl %ebp, 0xc(%rsp)
jmp 0x2e77
leaq 0x189e(%rip), %rdi      # 0x46d3
callq 0x2c45
movq %r15, %rdi
callq 0x1896
cmpl %ebp, %eax
jb 0x2eba
movl 0x28(%r15), %esi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
movq %r12, %rcx
callq 0x18d2
testl %eax, %eax
jns 0x2e6e
movl 0x8(%rsp), %esi
leaq 0x18c7(%rip), %rdi      # 0x4730
callq 0x2c45
movb $0x1, %al
cmpl 0x10(%rsp), %r13d
jne 0x2e9b
testb %al, %al
je 0x2e83
incl %ebp
cmpl %ebp, %ebx
jne 0x2e07
jmp 0x2e87
movl 0xc(%rsp), %ebx
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1898(%rip), %rdi      # 0x473a
leaq 0x17a9(%rip), %rsi      # 0x4652
leaq 0x1846(%rip), %rcx      # 0x46f6
movl $0x9f, %edx
callq 0x1080
leaq 0x181a(%rip), %rdi      # 0x46db
leaq 0x178a(%rip), %rsi      # 0x4652
leaq 0x1827(%rip), %rcx      # 0x46f6
movl $0x9a, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x2bb0
leaq -0xd0(%rbp), %rax
movl %ebx, (%rax)
leaq -0x2c(%rbp), %r12
leaq -0x160(%rbp), %r15
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2ca4
movq %r14, %rdi
movq -0x48(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1a9d
testl %eax, %eax
je 0x3079
movl -0x34(%rbp), %eax
cmpl $0x4, %eax
jne 0x3067
movl %ebx, -0x30(%rbp)
leaq 0x1906(%rip), %rdi      # 0x487b
callq 0x1060
testb $0x4, 0x12(%r14)
je 0x3040
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1f43
movl %eax, %r13d
movq %r14, %rdi
callq 0x2ca4
movq %r14, %rdi
cmpl $-0x1, %r13d
je 0x2fd7
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x18d2
testl %eax, %eax
jns 0x2fc4
movl -0x2c(%rbp), %esi
leaq 0x1771(%rip), %rdi      # 0x4730
callq 0x2c45
movq %r14, %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1eb5
jmp 0x2fe3
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1a9d
movl %eax, %r13d
movq %r14, %rdi
callq 0x2ca4
testl %r13d, %r13d
jns 0x302f
movl -0x2c(%rbp), %esi
cmpl $0x4, %esi
jne 0x3023
leaq 0x18a2(%rip), %rdi      # 0x48a4
callq 0x1060
leal 0x1(%rbx), %r13d
cmpl $0x7, %ebx
jl 0x3032
leaq 0x1857(%rip), %rdi      # 0x486e
movl $0x3, %esi
callq 0x2c45
jmp 0x3032
leaq 0x184c(%rip), %rdi      # 0x4876
callq 0x2c45
movl %ebx, %r13d
testb $0x4, 0x12(%r14)
movl %r13d, %ebx
jne 0x2f87
movq %r14, %rdi
callq 0x2ca4
leaq 0x183f(%rip), %rdi      # 0x488e
callq 0x1060
movl -0x30(%rbp), %ebx
incl %ebx
cmpl $0x8, %ebx
jne 0x2f38
movl $0x3, %eax
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x3072
movl %eax, (%rcx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x307b
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_O1/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 0x4485
movq 0x8(%rbx), %rdi
leaq 0x53(%rip), %r14        # 0x4491
movq %r14, %rsi
callq 0x2db5
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2db5
movq 0x8(%rbx), %rdi
callq 0x2bde
movq 0x10(%rbx), %rdi
callq 0x2bde
movq (%rbx), %rdi
callq 0x32ca
movq 0x28(%rbx), %rdi
leaq 0x43d1(%rip), %rsi      # 0x8848
callq 0x2db5
movq 0x28(%rbx), %rdi
callq 0x2bde
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/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 0x44c0
cmpl $0x2d, 0x8(%rbx)
jne 0x44b7
movq 0x20(%rbx), %rdi
callq 0x7cad
movq 0x38(%rbx), %rdi
callq 0x3cb6
movq 0x10(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/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 0x39b4
cmpl $0x70, %eax
jne 0x4512
leaq 0x6b75(%rip), %rsi      # 0xb076
xorl %r15d, %r15d
xorl %edi, %edi
xorl %eax, %eax
callq 0x22f9
jmp 0x4632
xorl %r12d, %r12d
movq (%rbx), %rdi
callq 0x331a
movq %rax, %r14
addl $-0x42, %eax
cmpl $0x2, %eax
jb 0x453f
leal -0x40(%r14), %eax
cmpl $0x1, %eax
ja 0x454a
movb $0x1, %r13b
xorl %eax, %eax
leaq 0x473(%rip), %r15       # 0x49b0
jmp 0x4552
xorl %eax, %eax
leaq 0x7e0(%rip), %r15       # 0x4d28
jmp 0x454f
movb $0x1, %al
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%rbx), %rdi
testb %al, %al
jne 0x45a7
callq 0x331a
cmpq $0x32, %rax
jne 0x45c1
movq %rbx, %rdi
movl %r14d, %esi
callq *%r15
cmpl $-0x1, %eax
je 0x45c9
movq (%rbx), %rdi
callq 0x331a
cmpq $0x33, %rax
jne 0x45cd
movq (%rbx), %rdi
callq 0x331a
xorl %r15d, %r15d
cmpq $0x30, %rax
jne 0x45d5
movq (%rbx), %rdi
callq 0x39b4
cmpl $0x70, %eax
jne 0x4515
jmp 0x4632
movslq 0x28(%rdi), %rdi
leaq 0x6b41(%rip), %rsi      # 0xb0f3
xorl %eax, %eax
callq 0x4060
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x4632
movl $0x7b, %r12d
jmp 0x45db
movb $0x1, %al
jmp 0x45dd
movl $0x7d, %r12d
jmp 0x45db
movl $0x3b, %r12d
xorl %eax, %eax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb %al, %al
jne 0x4632
movq (%rbx), %rax
cmpl $0x41, %r14d
leaq 0x66a9(%rip), %rcx      # 0xac9e
leaq 0x669c(%rip), %rdx      # 0xac98
cmoveq %rcx, %rdx
cmpl $0x43, %r14d
leaq 0x66a3(%rip), %rsi      # 0xacae
leaq 0x6693(%rip), %rcx      # 0xaca5
cmoveq %rsi, %rcx
movslq 0x28(%rax), %rdi
testb %r13b, %r13b
cmovneq %rdx, %rcx
leaq 0x6ae2(%rip), %rsi      # 0xb10a
movl %r12d, %edx
xorl %eax, %eax
callq 0x4060
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b4a
testq %rax, %rax
je 0x469c
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl %r14d, %edi
callq 0x3260
movq %rax, (%rbx)
callq 0x2b3c
movq %rax, 0x8(%rbx)
callq 0x2b3c
movq %rax, 0x10(%rbx)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movb $0x1, 0x1c(%rbx)
jmp 0x469e
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x44dc
cmpl $-0x1, %eax
jne 0x46b5
movq %rbx, %rdi
callq 0x4424
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49a1
movq %rdi, %rbx
leaq 0x6769(%rip), %r14      # 0xb0cb
leaq 0x677a(%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 0x496c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfl/src/lexical_spec.c
// Function: spec_state_token_list
int
spec_state_token_list(lexical_spec_t* spec, int kind_section) {
    if (peek_token(spec->lex) == T_RBRACE)
        { return (DONE); }
    else if (advance_token(spec->lex) == T_TERMINAL) {
        spec_entry_t* entry = add_entry_lexeme(spec, kind_section);
        if (!entry)
            { return (ERROR); }

        ++(entry->count);
        if (kind_section == T_STATE)
            { entry->is_defined = true; }

        if (peek_token(spec->lex) == T_BARROW) {
            if (kind_section == T_KEYWORD) {
                errorf(CURRENT_LINE(spec->lex),
                            "A '=>' can't appear in the $KEYWORD section.");
                return (ERROR);
            }

            advance_token(spec->lex);
            if (advance_token(spec->lex) != T_INITIAL) {
                errorf(CURRENT_LINE(spec->lex),
                            "Missing $INITIAL after the '=>' in the $STATE.");
                return (ERROR);
            }
            else if (spec->start_state != -1)
                { warnf(CURRENT_LINE(spec->lex), "Override initial state."); }
            spec->start_state = GET_INDEX(entry);
        }

        if (peek_token(spec->lex) == T_COMMA) {
            advance_token(spec->lex);
            return (spec_state_token_list(spec, kind_section));
        }
    }
    else {
        errorf(CURRENT_LINE(spec->lex),
                            "Expected identifier in the %s section.",
                            STATE_TYPE_LST_SECT(kind_section));
        return (ERROR);
    }
    return (DONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x69a6(%rip), %r15      # 0xb6e8
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq (%r14), %rdi
callq 0x39b4
cmpl $0x33, %eax
je 0x4df5
movq (%r14), %rdi
callq 0x331a
cmpq $0x2d, %rax
jne 0x4dfa
movq %r14, %rdi
movl %ebx, %esi
callq 0x4e60
testq %rax, %rax
je 0x4e4e
movq %rax, %r13
incq 0x28(%rax)
cmpl $0x43, %ebx
jne 0x4d8f
movb $0x1, 0x20(%r13)
movq (%r14), %rdi
callq 0x39b4
cmpl $0x2f, %eax
jne 0x4ddb
movq (%r14), %rdi
cmpl $0x42, %ebx
je 0x4e2c
callq 0x331a
movq (%r14), %rdi
callq 0x331a
cmpq $0x45, %rax
jne 0x4e39
cmpl $-0x1, 0x18(%r14)
je 0x4dd3
movq (%r14), %rax
movslq 0x28(%rax), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22f9
movl (%r13), %eax
movl %eax, 0x18(%r14)
movq (%r14), %rdi
callq 0x39b4
cmpl $0x31, %eax
jne 0x4df5
movq (%r14), %rdi
callq 0x331a
jmp 0x4d48
xorl %r12d, %r12d
jmp 0x4e4e
movq (%r14), %rax
movslq 0x28(%rax), %rdi
cmpl $0x43, %ebx
leaq 0x5ea3(%rip), %rax      # 0xacae
leaq 0x5e93(%rip), %rdx      # 0xaca5
cmoveq %rax, %rdx
leaq 0x68e3(%rip), %rsi      # 0xb700
xorl %eax, %eax
callq 0x4060
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x4e4e
movslq 0x28(%rdi), %rdi
leaq 0x6855(%rip), %rsi      # 0xb68c
jmp 0x4e47
movq (%r14), %rax
movslq 0x28(%rax), %rdi
leaq 0x6872(%rip), %rsi      # 0xb6b9
xorl %eax, %eax
callq 0x4060
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x331a
cmpq $0x34, %rax
jne 0x5087
leaq -0x28(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50d3
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x50a2
leaq -0x28(%rbp), %r12
movq (%rbx), %rdi
callq 0x39b4
cmpl $0x31, %eax
jne 0x50b2
movq (%rbx), %rdi
callq 0x331a
movq (%rbx), %rdi
callq 0x39b4
cmpl $0x35, %eax
je 0x50b2
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x50d3
cmpl $-0x1, %eax
jne 0x5050
jmp 0x50a2
movq (%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x62ee(%rip), %rsi      # 0xb383
xorl %eax, %eax
callq 0x4060
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 0x331a
xorl %r15d, %r15d
cmpq $0x35, %rax
je 0x50a2
movq (%rbx), %rax
movslq 0x28(%rax), %rdi
leaq 0x62e6(%rip), %rsi      # 0xb3b7
jmp 0x5095
// File: /workspace/github_c_makefile_star2_O1/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 0x18919(%rip), %rdi     # 0x1deb0
leaq 0x31(%rip), %rsi        # 0x55cf
callq 0x2db5
movq 0x18906(%rip), %rdi     # 0x1deb0
callq 0x2bde
movq 0x18902(%rip), %rdi     # 0x1deb8
leaq 0x46(%rip), %rsi        # 0x5603
callq 0x2db5
movq 0x188ef(%rip), %rdi     # 0x1deb8
popq %rbp
jmp 0x2bde
// File: /workspace/github_c_makefile_star2_O1/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 0x55f5
cmpl $-0x2, 0x10(%rbx)
jne 0x55ec
movq 0x28(%rbx), %rdi
callq 0x24ca
movq 0x30(%rbx), %rdi
callq 0x24ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2040