LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
	static char buf[BUFSIZ];
	static int buflen = 0;
	int ret, written;

	/* append read bytes to unprocessed bytes */
	ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);

	switch (ret) {
	case 0:
		exit(0);
	case -1:
		die("couldn't read from shell: %s\n", strerror(errno));
	default:
		buflen += ret;
		written = twrite(buf, buflen, 0);
		buflen -= written;
		/* keep any incomplete UTF-8 byte sequence for the next call */
		if (buflen > 0)
			memmove(buf, buf + written, buflen);
		if (term.scr > 0 && term.scr < HISTSIZE-1)
			term.scr++;
		return ret;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x17fa6(%rip), %edi     # 0x200e4
movslq 0x19fab(%rip), %rax     # 0x220f0
leaq 0x17fa4(%rip), %rsi     # 0x200f0
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6210
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $-0x1, %eax
je 0x817c
jmp 0x816c
movl -0xc(%rbp), %eax
testl %eax, %eax
jne 0x8199
jmp 0x8175
xorl %edi, %edi
callq 0x61b0
callq 0x66e0
movl (%rax), %edi
callq 0x6570
movq %rax, %rsi
leaq 0xc756(%rip), %rdi      # 0x148e8
movb $0x0, %al
callq 0x6c20
movl -0x4(%rbp), %eax
addl 0x19f4e(%rip), %eax     # 0x220f0
movl %eax, 0x19f48(%rip)     # 0x220f0
movl 0x19f42(%rip), %esi     # 0x220f0
leaq 0x17f3b(%rip), %rdi     # 0x200f0
xorl %edx, %edx
callq 0x8230
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
movl 0x19f28(%rip), %eax     # 0x220f0
subl %ecx, %eax
movl %eax, 0x19f20(%rip)     # 0x220f0
cmpl $0x0, 0x19f19(%rip)     # 0x220f0
jle 0x81fa
movslq -0x8(%rbp), %rax
leaq 0x17f0c(%rip), %rsi     # 0x200f0
addq %rax, %rsi
movslq 0x19f02(%rip), %rdx     # 0x220f0
leaq 0x17efb(%rip), %rdi     # 0x200f0
callq 0x6630
cmpl $0x0, 0x17e7b(%rip)     # 0x2007c
jle 0x821e
cmpl $0x7cf, 0x17e6f(%rip)   # imm = 0x7CF
jge 0x821e
movl 0x17e67(%rip), %eax     # 0x2007c
addl $0x1, %eax
movl %eax, 0x17e5e(%rip)     # 0x2007c
movslq -0x4(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: twrite
int
twrite(const char *buf, int buflen, int show_ctrl)
{
	int charsize;
	Rune u;
	int n;

	for (n = 0; n < buflen; n += charsize) {
		if (IS_SET(MODE_UTF8)) {
			/* process a complete utf8 char */
			charsize = utf8decode(buf + n, &u, buflen - n);
			if (charsize == 0)
				break;
		} else {
			u = buf[n] & 0xFF;
			charsize = 1;
		}
		if (show_ctrl && ISCONTROL(u)) {
			if (u & 0x80) {
				u &= 0x7f;
				tputc('^');
				tputc('[');
			} else if (u != '\n' && u != '\r' && u != '\t') {
				u ^= 0x40;
				tputc('^');
			}
		}
		tputc(u);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8342
movl 0x17e59(%rip), %eax     # 0x200b4
andl $0x40, %eax
cmpl $0x0, %eax
je 0x8290
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
leaq -0x18(%rbp), %rsi
callq 0xa550
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x828e
jmp 0x8342
jmp 0x82ab
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x832c
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
ja 0x82be
cmpl $0x1f, -0x18(%rbp)
jbe 0x82d7
cmpl $0x7f, -0x18(%rbp)
je 0x82d7
movl $0x80, %eax
cmpl -0x18(%rbp), %eax
ja 0x832c
cmpl $0x9f, -0x18(%rbp)
ja 0x832c
movl -0x18(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8303
movl -0x18(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x18(%rbp)
movl $0x5e, %edi
callq 0xa680
movl $0x5b, %edi
callq 0xa680
jmp 0x832a
cmpl $0xa, -0x18(%rbp)
je 0x8328
cmpl $0xd, -0x18(%rbp)
je 0x8328
cmpl $0x9, -0x18(%rbp)
je 0x8328
movl -0x18(%rbp), %eax
xorl $0x40, %eax
movl %eax, -0x18(%rbp)
movl $0x5e, %edi
callq 0xa680
jmp 0x832a
jmp 0x832c
movl -0x18(%rbp), %edi
callq 0xa680
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x8249
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: ttywrite
void
ttywrite(const char *s, size_t n, int may_echo)
{
	const char *next;
	Arg arg = (Arg) { .i = term.scr };

	kscrolldown(&arg);

	if (may_echo && IS_SET(MODE_ECHO))
		twrite(s, n, 1);

	if (!IS_SET(MODE_CRLF)) {
		ttywriteraw(s, n);
		return;
	}

	/* This is similar to how the kernel handles ONLCR for ttys */
	while (n > 0) {
		if (*s == '\r') {
			next = s + 1;
			ttywriteraw("\r\n", 2);
		} else {
			next = memchr(s, '\r', n);
			DEFAULT(next, s + n);
			ttywriteraw(s, next - s);
		}
		n -= next - s;
		s = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl 0x17d13(%rip), %eax     # 0x2007c
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8470
cmpl $0x0, -0x14(%rbp)
je 0x839d
movl 0x17d33(%rip), %eax     # 0x200b4
andl $0x10, %eax
cmpl $0x0, %eax
je 0x839d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movl $0x1, %edx
callq 0x8230
movl 0x17d11(%rip), %eax     # 0x200b4
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x83bd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x84e0
jmp 0x8467
jmp 0x83bf
cmpq $0x0, -0x10(%rbp)
jbe 0x8467
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x83f5
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0xc51d(%rip), %rdi      # 0x14906
movl $0x2, %esi
callq 0x84e0
jmp 0x8444
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xd, %esi
callq 0x6130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x841c
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x8428
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
subq %rax, %rsi
callq 0x84e0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x83bf
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: kscrolldown
void
kscrolldown(const Arg* a)
{
	int n = a->i;

	if (n < 0)
		n = term.row + n;

	if (n > term.scr)
		n = term.scr;

	if (term.scr > 0) {
		term.scr -= n;
		selscroll(0, -n);
		tfulldirt();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8497
movl 0x13d4f(%rip), %eax     # 0x1c1e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x17bdc(%rip), %eax     # 0x2007c
jle 0x84ab
movl 0x17bd4(%rip), %eax     # 0x2007c
movl %eax, -0xc(%rbp)
cmpl $0x0, 0x17bca(%rip)     # 0x2007c
jle 0x84d6
movl -0xc(%rbp), %ecx
movl 0x17bbf(%rip), %eax     # 0x2007c
subl %ecx, %eax
movl %eax, 0x17bb7(%rip)     # 0x2007c
xorl %esi, %esi
subl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x90c0
callq 0x91d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: ttyresize
void
ttyresize(int tw, int th)
{
	struct winsize w;

	w.ws_row = term.row;
	w.ws_col = term.col;
	w.ws_xpixel = tw;
	w.ws_ypixel = th;
	if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
		fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x139cc(%rip), %eax     # 0x1c1e0
movw %ax, -0x10(%rbp)
movl 0x139c6(%rip), %eax     # 0x1c1e4
movw %ax, -0xe(%rbp)
movl -0x4(%rbp), %eax
movw %ax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movw %ax, -0xa(%rbp)
movl 0x178ae(%rip), %edi     # 0x200e4
movl $0x5414, %esi           # imm = 0x5414
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x6110
cmpl $0x0, %eax
jge 0x887a
movq 0x1079e(%rip), %rax     # 0x18ff0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x66e0
movl (%rax), %edi
callq 0x6570
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xc096(%rip), %rsi      # 0x14909
movb $0x0, %al
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tattrset
int
tattrset(int attr)
{
	int i, j;

	for (i = 0; i < term.row-1; i++) {
		for (j = 0; j < term.col-1; j++) {
			if (term.line[i][j].mode & attr)
				return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x13929(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x891e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x13916(%rip), %ecx     # 0x1c1e4
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8911
movq 0x1390c(%rip), %rax     # 0x1c1e8
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0x8904
movl $0x1, -0x4(%rbp)
jmp 0x8925
jmp 0x8906
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x88c5
jmp 0x8913
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x88ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tsetdirtattr
void
tsetdirtattr(int attr)
{
	int i, j;

	for (i = 0; i < term.row-1; i++) {
		for (j = 0; j < term.col-1; j++) {
			if (term.line[i][j].mode & attr) {
				tsetdirt(i, i);
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl 0x13895(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x89b6
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x13882(%rip), %ecx     # 0x1c1e4
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x89a9
movq 0x13878(%rip), %rax     # 0x1c1e8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x899c
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x71a0
jmp 0x89a9
jmp 0x899e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8959
jmp 0x89ab
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8942
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: treset
void
treset(void)
{
	uint i;

	term.c = (TCursor){{
		.mode = ATTR_NULL,
		.fg = defaultfg,
		.bg = defaultbg
	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};

	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
	for (i = tabspaces; i < term.col; i += tabspaces)
		term.tabs[i] = 1;
	term.top = 0;
	term.bot = term.row - 1;
	term.mode = MODE_WRAP|MODE_UTF8;
	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
	term.charset = 0;

	for (i = 0; i < 2; i++) {
		tmoveto(0, 0);
		tcursor(CURSOR_SAVE);
		tclearregion(0, 0, term.col-1, term.row-1);
		tswapscreen();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x20(%rbp)
movw $0x0, -0x1c(%rbp)
leaq 0x10830(%rip), %rax     # 0x197ac
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x10828(%rip), %rax     # 0x197b0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x170de(%rip)     # 0x20088
movq -0x18(%rbp), %rax
movq %rax, 0x170db(%rip)     # 0x20090
movq -0x10(%rbp), %rax
movq %rax, 0x170d8(%rip)     # 0x20098
movl -0x8(%rbp), %eax
movl %eax, 0x170d7(%rip)     # 0x200a0
movq 0x170f8(%rip), %rdi     # 0x200c8
movslq 0x1320d(%rip), %rdx     # 0x1c1e4
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60b0
leaq 0x107bf(%rip), %rax     # 0x197a8
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x131ed(%rip), %eax     # 0x1c1e4
jae 0x901b
movq 0x170c8(%rip), %rax     # 0x200c8
movl -0x4(%rbp), %ecx
movl $0x1, (%rax,%rcx,4)
leaq 0x10797(%rip), %rax     # 0x197a8
movl (%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8fee
movl $0x0, 0x17087(%rip)     # 0x200ac
movl 0x131b5(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, 0x1707c(%rip)     # 0x200b0
movl $0x41, 0x17076(%rip)    # 0x200b4
leaq 0x1319b(%rip), %rdi     # 0x1c1e0
addq $0x3edc, %rdi           # imm = 0x3EDC
movl $0x3, %esi
movl $0x4, %edx
callq 0x60b0
movl $0x0, 0x1705b(%rip)     # 0x200c0
movl $0x0, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jae 0x90ad
xorl %esi, %esi
movl %esi, %edi
callq 0x97e0
xorl %edi, %edi
callq 0x9af0
movl 0x1315c(%rip), %edx     # 0x1c1e4
subl $0x1, %edx
movl 0x1314f(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x98b0
callq 0x9aa0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x906c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: selscroll
void
selscroll(int orig, int n)
{
	if (sel.ob.x == -1)
		return;

	if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) {
		selclear();
	} else if (BETWEEN(sel.nb.y, orig, term.bot)) {
		sel.ob.y += n;
		sel.oe.y += n;
		if (sel.ob.y < term.top || sel.ob.y > term.bot ||
		    sel.oe.y < term.top || sel.oe.y > term.bot) {
			selclear();
		} else {
			selnormalize();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, 0x130f7(%rip)    # 0x1c1cc
jne 0x90dc
jmp 0x91c1
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0x130d9(%rip), %ecx     # 0x1c1c0
movb %al, -0x9(%rbp)
jg 0x90fe
movl 0x130ce(%rip), %eax     # 0x1c1c0
cmpl 0x16fb8(%rip), %eax     # 0x200b0
setle %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0x130b4(%rip), %ecx     # 0x1c1c8
movb %al, -0xa(%rbp)
jg 0x912b
movl 0x130a9(%rip), %eax     # 0x1c1c8
cmpl 0x16f8b(%rip), %eax     # 0x200b0
setle %al
movb %al, -0xa(%rbp)
movl -0x10(%rbp), %eax
movb -0xa(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x9142
callq 0x6fb0
jmp 0x91c1
movl -0x4(%rbp), %eax
cmpl 0x13075(%rip), %eax     # 0x1c1c0
jg 0x91bf
movl 0x1306d(%rip), %eax     # 0x1c1c0
cmpl 0x16f57(%rip), %eax     # 0x200b0
jg 0x91bf
movl -0x8(%rbp), %eax
addl 0x1306c(%rip), %eax     # 0x1c1d0
movl %eax, 0x13066(%rip)     # 0x1c1d0
movl -0x8(%rbp), %eax
addl 0x13065(%rip), %eax     # 0x1c1d8
movl %eax, 0x1305f(%rip)     # 0x1c1d8
movl 0x13051(%rip), %eax     # 0x1c1d0
cmpl 0x16f27(%rip), %eax     # 0x200ac
jl 0x91b1
movl 0x13043(%rip), %eax     # 0x1c1d0
cmpl 0x16f1d(%rip), %eax     # 0x200b0
jg 0x91b1
movl 0x1303d(%rip), %eax     # 0x1c1d8
cmpl 0x16f0b(%rip), %eax     # 0x200ac
jl 0x91b1
movl 0x1302f(%rip), %eax     # 0x1c1d8
cmpl 0x16f01(%rip), %eax     # 0x200b0
jle 0x91b8
callq 0x6fb0
jmp 0x91bd
callq 0x6ff0
jmp 0x91bf
jmp 0x91c1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: kscrollup
void
kscrollup(const Arg* a)
{
	int n = a->i;

	if (n < 0)
		n = term.row + n;

	if (term.scr <= HISTSIZE-n) {
		term.scr += n;
		selscroll(0, n);
		tfulldirt();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x9217
movl 0x12fcf(%rip), %eax     # 0x1c1e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x16e5f(%rip), %eax     # 0x2007c
movl $0x7d0, %ecx            # imm = 0x7D0
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jg 0x9247
movl -0xc(%rbp), %eax
addl 0x16e4a(%rip), %eax     # 0x2007c
movl %eax, 0x16e44(%rip)     # 0x2007c
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x90c0
callq 0x91d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: xwrite
ssize_t
xwrite(int fd, const char *s, size_t len)
{
	size_t aux = len;
	ssize_t r;

	while (len > 0) {
		r = write(fd, s, len);
		if (r < 0)
			return r;
		len -= r;
		s += r;
	}

	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x9524
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x69e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x9507
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x952c
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x94db
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: iso14755
void
iso14755(const Arg *arg)
{
	FILE *p;
	char *us, *e, codepoint[9], uc[UTF_SIZ];
	unsigned long utf32;

	if (!(p = popen(ISO14755CMD, "r")))
		return;

	us = fgets(codepoint, sizeof(codepoint), p);
	pclose(p);

	if (!us || *us == '\0' || *us == '-' || strlen(us) > 7)
		return;
	if ((utf32 = strtoul(us, &e, 16)) == ULONG_MAX ||
	    (*e != '\n' && *e != '\0'))
		return;

	ttywrite(uc, utf8encode(utf32, uc), 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb3f7(%rip), %rdi      # 0x1494a
leaq 0xc056(%rip), %rsi      # 0x155b0
callq 0x6a10
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x956e
jmp 0x961b
leaq -0x29(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x9, %esi
callq 0x6320
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6440
cmpq $0x0, -0x18(%rbp)
je 0x95bb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x95bb
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x95bb
movq -0x18(%rbp), %rdi
callq 0x6410
cmpq $0x7, %rax
jbe 0x95bd
jmp 0x961b
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x6a20
movq %rax, -0x38(%rbp)
cmpq $-0x1, %rax
je 0x95f1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x95f3
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x95f3
jmp 0x961b
leaq -0x2d(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %edi
leaq -0x2d(%rbp), %rsi
callq 0x6d70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x8350
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tsetscroll
void
tsetscroll(int t, int b)
{
	int temp;

	LIMIT(t, 0, term.row-1);
	LIMIT(b, 0, term.row-1);
	if (t > b) {
		temp = t;
		t = b;
		b = temp;
	}
	term.top = t;
	term.bot = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x9737
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x9761
movl -0x4(%rbp), %eax
movl 0x12aa0(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x9755
movl 0x12a93(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x975b
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x9774
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x979e
movl -0x8(%rbp), %eax
movl 0x12a63(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x9792
movl 0x12a56(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9798
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x97be
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x168e5(%rip)     # 0x200ac
movl -0x8(%rbp), %eax
movl %eax, 0x168e0(%rip)     # 0x200b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tmoveto
void
tmoveto(int x, int y)
{
	int miny, maxy;

	if (term.c.state & CURSOR_ORIGIN) {
		miny = term.top;
		maxy = term.bot;
	} else {
		miny = 0;
		maxy = term.row - 1;
	}
	term.c.state &= ~CURSOR_WRAPNEXT;
	term.c.x = LIMIT(x, 0, term.col-1);
	term.c.y = LIMIT(y, miny, maxy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsbl 0x168af(%rip), %eax     # 0x200a0
andl $0x2, %eax
cmpl $0x0, %eax
je 0x980d
movl 0x168ad(%rip), %eax     # 0x200ac
movl %eax, -0xc(%rbp)
movl 0x168a8(%rip), %eax     # 0x200b0
movl %eax, -0x10(%rbp)
jmp 0x9820
movl $0x0, -0xc(%rbp)
movl 0x129c6(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movsbl 0x16879(%rip), %eax     # 0x200a0
andl $-0x2, %eax
movb %al, 0x16870(%rip)      # 0x200a0
cmpl $0x0, -0x4(%rbp)
jge 0x983d
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x9867
movl -0x4(%rbp), %eax
movl 0x1299e(%rip), %ecx     # 0x1c1e4
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x985b
movl 0x12991(%rip), %eax     # 0x1c1e4
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9861
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl %eax, 0x16825(%rip)     # 0x20098
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9883
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x989f
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x9893
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x9899
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl %eax, 0x167f1(%rip)     # 0x2009c
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tswapscreen
void
tswapscreen(void)
{
	Line *tmp = term.line;

	term.line = term.alt;
	term.alt = tmp;
	term.mode ^= MODE_ALTSCREEN;
	tfulldirt();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x12739(%rip), %rax     # 0x1c1e8
movq %rax, -0x8(%rbp)
movq 0x12736(%rip), %rax     # 0x1c1f0
movq %rax, 0x12727(%rip)     # 0x1c1e8
movq -0x8(%rbp), %rax
movq %rax, 0x12724(%rip)     # 0x1c1f0
movl 0x165e2(%rip), %eax     # 0x200b4
xorl $0x4, %eax
movl %eax, 0x165d9(%rip)     # 0x200b4
callq 0x91d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tcursor
void
tcursor(int mode)
{
	static TCursor c[2];
	int alt = IS_SET(MODE_ALTSCREEN);

	if (mode == CURSOR_SAVE) {
		c[alt] = term.c;
	} else if (mode == CURSOR_LOAD) {
		term.c = c[alt];
		tmoveto(c[alt].x, c[alt].y);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x165b3(%rip), %eax     # 0x200b4
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x9b55
movslq -0x8(%rbp), %rcx
leaq 0x188dd(%rip), %rax     # 0x22400
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq 0x16557(%rip), %rcx     # 0x20088
movq %rcx, (%rax)
movq 0x16555(%rip), %rcx     # 0x20090
movq %rcx, 0x8(%rax)
movq 0x16552(%rip), %rcx     # 0x20098
movq %rcx, 0x10(%rax)
movl 0x16550(%rip), %ecx     # 0x200a0
movl %ecx, 0x18(%rax)
jmp 0x9bc7
cmpl $0x1, -0x4(%rbp)
jne 0x9bc5
movslq -0x8(%rbp), %rcx
leaq 0x1889a(%rip), %rax     # 0x22400
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x16511(%rip)     # 0x20088
movq 0x8(%rax), %rcx
movq %rcx, 0x1650e(%rip)     # 0x20090
movq 0x10(%rax), %rcx
movq %rcx, 0x1650b(%rip)     # 0x20098
movl 0x18(%rax), %eax
movl %eax, 0x1650a(%rip)     # 0x200a0
movslq -0x8(%rbp), %rcx
leaq 0x1885f(%rip), %rax     # 0x22400
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edi
movslq -0x8(%rbp), %rcx
leaq 0x1884a(%rip), %rax     # 0x22400
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %esi
callq 0x97e0
jmp 0x9bc7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: drawregion
void
drawregion(int x1, int y1, int x2, int y2)
{
	int y;

	for (y = y1; y < y2; y++) {
		if (!term.dirty[y])
			continue;

		term.dirty[y] = 0;
		xdrawline(TLINE(y), x1, y, x2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x9ed5
movq 0x16243(%rip), %rax     # 0x20080
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x9e49
jmp 0x9ec7
movq 0x16230(%rip), %rax     # 0x20080
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
cmpl 0x16218(%rip), %eax     # 0x2007c
jge 0x9e9a
movl -0x14(%rbp), %eax
addl 0x16209(%rip), %eax     # 0x20078
subl 0x16207(%rip), %eax     # 0x2007c
addl $0x7d0, %eax            # imm = 0x7D0
addl $0x1, %eax
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x12351(%rip), %rax     # 0x1c1e0
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x9eb5
movq 0x12347(%rip), %rax     # 0x1c1e8
movl -0x14(%rbp), %ecx
subl 0x161d2(%rip), %ecx     # 0x2007c
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0xeb50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9e2a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: cleanup
void
cleanup()
{
	int i;
	close(cmdfd);
	for (i = 0; i < ncleanfunc; i++)
		cleanfuncs[i]();
	free(cleanfuncs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x15d16(%rip), %edi     # 0x200e4
callq 0x60f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x15cfd(%rip), %eax     # 0x200e0
jge 0xa400
movq 0x15cec(%rip), %rcx     # 0x200d8
movslq -0x4(%rbp), %rdx
movb $0x0, %al
callq *(%rcx,%rdx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa3da
movq 0x15cd1(%rip), %rdi     # 0x200d8
callq 0x63d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tprinter
void
tprinter(char *s, size_t len)
{
	if (iofd != -1 && xwrite(iofd, s, len) < 0) {
		perror("Error writing to output file");
		close(iofd);
		iofd = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $-0x1, 0xf149(%rip)     # 0x19580
je 0xa473
movl 0xf141(%rip), %edi      # 0x19580
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x94c0
cmpq $0x0, %rax
jge 0xa473
leaq 0xa686(%rip), %rdi      # 0x14adf
callq 0x69a0
movl 0xf11c(%rip), %edi      # 0x19580
callq 0x60f0
movl $0xffffffff, 0xf10d(%rip) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tdumpline
void
tdumpline(int n)
{
	char buf[UTF_SIZ];
	const Glyph *bp, *end;

	bp = &term.line[n][0];
	end = &bp[MIN(tlinelen(n), term.col) - 1];
	if (bp != end || bp->u != ' ') {
		for ( ; bp <= end; ++bp)
			tprinter(buf, utf8encode(bp->u, buf));
	}
	tprinter("\n", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x11d56(%rip), %rax     # 0x1c1e8
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x77f0
cmpl 0x11d30(%rip), %eax     # 0x1c1e4
jge 0xa4c3
movl -0x4(%rbp), %edi
callq 0x77f0
movl %eax, -0x24(%rbp)
jmp 0xa4cc
movl 0x11d1b(%rip), %eax     # 0x1c1e4
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xa4f7
movq -0x10(%rbp), %rax
cmpl $0x20, (%rax)
je 0xa536
jmp 0xa4f9
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xa534
leaq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x8(%rbp), %rsi
callq 0x6d70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xa420
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xa4f9
jmp 0xa536
leaq 0xa3ca(%rip), %rdi      # 0x14907
movl $0x1, %esi
callq 0xa420
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: utf8decode
size_t
utf8decode(const char *c, Rune *u, size_t clen)
{
	size_t i, j, len, type;
	Rune udecoded;

	*u = UTF_INVALID;
	if (!clen)
		return 0;
	udecoded = utf8decodebyte(c[0], &len);
	if (!BETWEEN(len, 1, UTF_SIZ))
		return 1;
	for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
		udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
		if (type != 0)
			return j;
	}
	if (j < len)
		return 0;
	*u = udecoded;
	utf8validate(u, len);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
cmpq $0x0, -0x20(%rbp)
jne 0xa582
movq $0x0, -0x8(%rbp)
jmp 0xa671
movq -0x10(%rbp), %rax
leaq -0x38(%rbp), %rsi
movsbl (%rax), %edi
callq 0xaba0
movl %eax, -0x44(%rbp)
movl $0x1, %eax
cmpq -0x38(%rbp), %rax
ja 0xa5a7
cmpq $0x4, -0x38(%rbp)
jbe 0xa5b4
movq $0x1, -0x8(%rbp)
jmp 0xa671
movq $0x1, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x45(%rbp)
jae 0xa5e1
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
setb %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xa5ea
jmp 0xa63f
movl -0x44(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rsi
movsbl (%rax,%rcx), %edi
callq 0xaba0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xa623
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa671
jmp 0xa625
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa5c4
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xa653
movq $0x0, -0x8(%rbp)
jmp 0xa671
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6e10
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: utf8decodebyte
Rune
utf8decodebyte(char c, size_t *i)
{
	for (*i = 0; *i < LEN(utfmask); ++(*i))
		if (((uchar)c & utfmask[*i]) == utfbyte[*i])
			return (uchar)c & ~utfmask[*i];

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x5, (%rax)
jae 0xac23
movzbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
leaq 0x9b30(%rip), %rcx      # 0x14705
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
leaq 0x9b17(%rip), %rcx      # 0x14700
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xac11
movzbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
leaq 0x9b02(%rip), %rcx      # 0x14705
movzbl (%rcx,%rdx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xac2a
jmp 0xac13
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xabb9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: csiparse
void
csiparse(void)
{
	char *p = csiescseq.buf, *np;
	long int v;

	csiescseq.narg = 0;
	if (*p == '?') {
		csiescseq.priv = 1;
		p++;
	}

	csiescseq.buf[csiescseq.len] = '\0';
	while (p < csiescseq.buf+csiescseq.len) {
		np = NULL;
		v = strtol(p, &np, 10);
		if (np == p)
			v = 0;
		if (v == LONG_MAX || v == LONG_MIN)
			v = -1;
		csiescseq.arg[csiescseq.narg++] = v;
		p = np;
		if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ)
			break;
		p++;
	}
	csiescseq.mode[0] = *p++;
	csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x173c1(%rip), %rax     # 0x221a0
movq %rax, -0x8(%rbp)
movl $0x0, 0x175ff(%rip)     # 0x223ec
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0xae0c
movb $0x1, 0x175a8(%rip)     # 0x223a8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq 0x1758d(%rip), %rcx     # 0x223a0
leaq 0x17386(%rip), %rax     # 0x221a0
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
leaq 0x17377(%rip), %rcx     # 0x221a0
addq 0x17570(%rip), %rcx     # 0x223a0
cmpq %rcx, %rax
jae 0xaee9
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x65d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0xae69
movq $0x0, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0xae89
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
jne 0xae91
movq $-0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edx
movl 0x1754f(%rip), %eax     # 0x223ec
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x17544(%rip)     # 0x223ec
movslq %eax, %rcx
leaq 0x172ee(%rip), %rax     # 0x221a0
movl %edx, 0x20c(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0xaed6
cmpl $0x10, 0x17518(%rip)    # 0x223ec
jne 0xaed8
jmp 0xaee9
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xae1e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, 0x174f0(%rip)      # 0x223f0
movq -0x8(%rbp), %rax
leaq 0x17295(%rip), %rcx     # 0x221a0
addq 0x1748e(%rip), %rcx     # 0x223a0
cmpq %rcx, %rax
jae 0xaf23
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xaf2a
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xaf2a
movl -0x1c(%rbp), %eax
movb %al, 0x174be(%rip)      # 0x223f1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tdefutf8
void
tdefutf8(char ascii)
{
	if (ascii == 'G')
		term.mode |= MODE_UTF8;
	else if (ascii == '@')
		term.mode &= ~MODE_UTF8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x47, %eax
jne 0xb934
movl 0x1478b(%rip), %eax     # 0x200b4
orl $0x40, %eax
movl %eax, 0x14782(%rip)     # 0x200b4
jmp 0xb94e
movsbl -0x1(%rbp), %eax
cmpl $0x40, %eax
jne 0xb94c
movl 0x14771(%rip), %eax     # 0x200b4
andl $-0x41, %eax
movl %eax, 0x14768(%rip)     # 0x200b4
jmp 0xb94e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tdeftran
void
tdeftran(char ascii)
{
	static char cs[] = "0B";
	static int vcs[] = {CS_GRAPHIC0, CS_USA};
	char *p;

	if ((p = strchr(cs, ascii)) == NULL) {
		fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
	} else {
		term.trantbl[term.icharset] = vcs[p - cs];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %esi
leaq 0xdc1b(%rip), %rdi      # 0x19584
callq 0x6640
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xb996
movq 0xd671(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
movsbl -0x1(%rbp), %edx
leaq 0x93ee(%rip), %rsi      # 0x14d7b
movb $0x0, %al
callq 0x69d0
jmp 0xb9c5
movq -0x10(%rbp), %rcx
leaq 0xdbe3(%rip), %rax      # 0x19584
subq %rax, %rcx
leaq 0xdbdd(%rip), %rax      # 0x19588
movl (%rax,%rcx,4), %eax
movb %al, %dl
movslq 0x1470d(%rip), %rcx     # 0x200c4
leaq 0x10822(%rip), %rax     # 0x1c1e0
movb %dl, 0x3edc(%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tdectest
void
tdectest(char c)
{
	int x, y;

	if (c == '8') { /* DEC screen alignment test. */
		for (x = 0; x < term.col; ++x) {
			for (y = 0; y < term.row; ++y)
				tsetchar('E', &term.c.attr, x, y);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x38, %eax
jne 0xba43
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x107ed(%rip), %eax     # 0x1c1e4
jge 0xba41
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x107d7(%rip), %eax     # 0x1c1e0
jge 0xba34
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl $0x45, %edi
leaq 0x107c3(%rip), %rsi     # 0x1c1e0
addq $0x3ea8, %rsi           # imm = 0x3EA8
callq 0xbd40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xba00
jmp 0xba36
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb9ee
jmp 0xba43
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tnewline
void
tnewline(int first_col)
{
	int y = term.c.y;

	if (y == term.bot) {
		tscrollup(term.top, 1, 1);
	} else {
		y++;
	}
	tmoveto(first_col ? 0 : term.c.x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x143bb(%rip), %eax     # 0x2009c
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x143c3(%rip), %eax     # 0x200b0
jne 0xbd03
movl 0x143b7(%rip), %edi     # 0x200ac
movl $0x1, %edx
movl %edx, %esi
callq 0xcd50
jmp 0xbd0c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xbd19
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0xbd22
movl 0x14379(%rip), %eax     # 0x20098
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x97e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tputtab
void
tputtab(int n)
{
	uint x = term.c.x;

	if (n > 0) {
		while (x < term.col && n--)
			for (++x; x < term.col && !term.tabs[x]; ++x)
				/* nothing */ ;
	} else if (n < 0) {
		while (x > 0 && n++)
			for (--x; x > 0 && !term.tabs[x]; --x)
				/* nothing */ ;
	}
	term.c.x = LIMIT(x, 0, term.col-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0x1415b(%rip), %eax     # 0x20098
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xbfbe
jmp 0xbf48
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x10291(%rip), %ecx     # 0x1c1e4
movb %al, -0x9(%rbp)
jae 0xbf6c
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xbf75
jmp 0xbfbc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x1025b(%rip), %ecx     # 0x1c1e4
movb %al, -0xa(%rbp)
jae 0xbfa4
movq 0x14133(%rip), %rax     # 0x200c8
movl -0x8(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0xbfad
jmp 0xbfba
jmp 0xbfaf
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbf7e
jmp 0xbf48
jmp 0xc034
cmpl $0x0, -0x4(%rbp)
jge 0xc032
jmp 0xbfc6
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0xb(%rbp)
jbe 0xbfe5
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0xbfee
jmp 0xc030
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0xc(%rbp)
jbe 0xc018
movq 0x140bf(%rip), %rax     # 0x200c8
movl -0x8(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
movb %al, -0xc(%rbp)
movb -0xc(%rbp), %al
testb $0x1, %al
jne 0xc021
jmp 0xc02e
jmp 0xc023
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbff7
jmp 0xbfc6
jmp 0xc032
jmp 0xc034
cmpl $0x0, -0x8(%rbp)
jae 0xc041
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0xc06b
movl -0x8(%rbp), %eax
movl 0x1019a(%rip), %ecx     # 0x1c1e4
subl $0x1, %ecx
cmpl %ecx, %eax
jbe 0xc05f
movl 0x1018d(%rip), %eax     # 0x1c1e4
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc065
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl %eax, 0x14021(%rip)     # 0x20098
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tstrsequence
void
tstrsequence(uchar c)
{
	switch (c) {
	case 0x90:   /* DCS -- Device Control String */
		c = 'P';
		break;
	case 0x9f:   /* APC -- Application Program Command */
		c = '_';
		break;
	case 0x9e:   /* PM -- Privacy Message */
		c = '^';
		break;
	case 0x9d:   /* OSC -- Operating System Command */
		c = ']';
		break;
	}
	strreset();
	strescseq.type = c;
	term.esc |= ESC_STR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
addl $0xffffff70, %eax       # imm = 0xFFFFFF70
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xf, %eax
ja 0xc49c
movq -0x10(%rbp), %rax
leaq 0x8127(%rip), %rcx      # 0x145a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x50, -0x1(%rbp)
jmp 0xc49c
movb $0x5f, -0x1(%rbp)
jmp 0xc49c
movb $0x5e, -0x1(%rbp)
jmp 0xc49c
movb $0x5d, -0x1(%rbp)
callq 0xca80
movb -0x1(%rbp), %al
movb %al, 0x15c4e(%rip)      # 0x220f8
movl 0x13c08(%rip), %eax     # 0x200b8
orl $0x4, %eax
movl %eax, 0x13bff(%rip)     # 0x200b8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: strparse
void
strparse(void)
{
	int c;
	char *p = strescseq.buf;

	strescseq.narg = 0;
	strescseq.buf[strescseq.len] = '\0';

	if (*p == '\0')
		return;

	while (strescseq.narg < STR_ARG_SIZ) {
		strescseq.args[strescseq.narg++] = p;
		while ((c = *p) != ';' && c != '\0')
			++p;
		if (c == '\0')
			return;
		*p++ = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x15c35(%rip), %rax     # 0x22100
movq %rax, -0x10(%rbp)
movl $0x0, 0x15cbf(%rip)     # 0x22198
movq 0x15c20(%rip), %rax     # 0x22100
movq 0x15c29(%rip), %rcx     # 0x22110
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc4fc
jmp 0xc57c
jmp 0xc4fe
cmpl $0x10, 0x15c93(%rip)    # 0x22198
jge 0xc57c
movq -0x10(%rbp), %rdx
movl 0x15c87(%rip), %eax     # 0x22198
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x15c7c(%rip)     # 0x22198
movslq %eax, %rcx
leaq 0x15bd2(%rip), %rax     # 0x220f8
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x3b, %ecx
movb %al, -0x11(%rbp)
je 0xc549
cmpl $0x0, -0x4(%rbp)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xc552
jmp 0xc560
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc52b
cmpl $0x0, -0x4(%rbp)
jne 0xc568
jmp 0xc57c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
jmp 0xc4fe
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: osc_color_response
void
osc_color_response(int num, int index, int is_osc4)
{
	int n;
	char buf[32];
	unsigned char r, g, b;

	if (xgetcolor(is_osc4 ? num : index, &r, &g, &b)) {
		fprintf(stderr, "erresc: failed to fetch %s color %d\n",
		        is_osc4 ? "osc4" : "osc",
		        is_osc4 ? num : index);
		return;
	}

	n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
	             is_osc4 ? "4;" : "", num, r, r, g, g, b, b);
	if (n < 0 || n >= sizeof(buf)) {
		fprintf(stderr, "error: %s while printing %s response\n",
		        n < 0 ? "snprintf failed" : "truncation occurred",
		        is_osc4 ? "osc4" : "osc");
	} else {
		ttywrite(buf, n, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xc725
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xc72b
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %edi
leaq -0x41(%rbp), %rsi
leaq -0x42(%rbp), %rdx
leaq -0x43(%rbp), %rcx
callq 0xe020
cmpl $0x0, %eax
je 0xc7a0
movq 0xc8a5(%rip), %rax      # 0x18ff0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x1c(%rbp), %edx
leaq 0x845d(%rip), %rax      # 0x14bb9
leaq 0x8451(%rip), %rcx      # 0x14bb4
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xc77c
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0xc782
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
leaq 0x83fb(%rip), %rsi      # 0x14b8f
movb $0x0, %al
callq 0x69d0
jmp 0xc874
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x9188(%rip), %rcx      # 0x15936
leaq 0x842f(%rip), %rax      # 0x14be4
cmpl $0x0, %edx
cmovneq %rax, %rcx
movl -0x14(%rbp), %r8d
movzbl -0x41(%rbp), %r9d
movzbl -0x41(%rbp), %r14d
movzbl -0x42(%rbp), %ebx
movzbl -0x42(%rbp), %r11d
movzbl -0x43(%rbp), %r10d
movzbl -0x43(%rbp), %eax
movl $0x20, %esi
leaq 0x83d5(%rip), %rdx      # 0x14bbd
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x60c0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xc818
movslq -0x20(%rbp), %rax
cmpq $0x20, %rax
jb 0xc862
movq 0xc7d1(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
movl -0x20(%rbp), %ecx
leaq 0x83f1(%rip), %rdx      # 0x14c1d
leaq 0x83da(%rip), %rax      # 0x14c0d
cmpl $0x0, %ecx
cmovlq %rax, %rdx
movl -0x1c(%rbp), %esi
leaq 0x8375(%rip), %rcx      # 0x14bb9
leaq 0x8369(%rip), %rax      # 0x14bb4
cmpl $0x0, %esi
cmovneq %rax, %rcx
leaq 0x838e(%rip), %rsi      # 0x14be7
movb $0x0, %al
callq 0x69d0
jmp 0xc874
leaq -0x40(%rbp), %rdi
movslq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x8350
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: strdump
void
strdump(void)
{
	size_t i;
	uint c;

	fprintf(stderr, "ESC%c", strescseq.type);
	for (i = 0; i < strescseq.len; i++) {
		c = strescseq.buf[i] & 0xff;
		if (c == '\0') {
			putc('\n', stderr);
			return;
		} else if (isprint(c)) {
			putc(c, stderr);
		} else if (c == '\n') {
			fprintf(stderr, "(\\n)");
		} else if (c == '\r') {
			fprintf(stderr, "(\\r)");
		} else if (c == 0x1b) {
			fprintf(stderr, "(\\e)");
		} else {
			fprintf(stderr, "(%02x)", c);
		}
	}
	fprintf(stderr, "ESC\\\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xc761(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
movsbl 0x1585f(%rip), %edx     # 0x220f8
leaq 0x8391(%rip), %rsi      # 0x14c31
movb $0x0, %al
callq 0x69d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x15856(%rip), %rax     # 0x22110
jae 0xc9bd
movq 0x15839(%rip), %rax     # 0x22100
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xc8f6
movq 0xc70c(%rip), %rax      # 0x18ff0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x6620
jmp 0xc9d5
callq 0x6460
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xc927
movl -0xc(%rbp), %edi
movq 0xc6d6(%rip), %rax      # 0x18ff0
movq (%rax), %rsi
callq 0x6620
jmp 0xc9a8
cmpl $0xa, -0xc(%rbp)
jne 0xc947
movq 0xc6bc(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x82f9(%rip), %rsi      # 0x14c37
movb $0x0, %al
callq 0x69d0
jmp 0xc9a6
cmpl $0xd, -0xc(%rbp)
jne 0xc967
movq 0xc69c(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x82de(%rip), %rsi      # 0x14c3c
movb $0x0, %al
callq 0x69d0
jmp 0xc9a4
cmpl $0x1b, -0xc(%rbp)
jne 0xc987
movq 0xc67c(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x82c3(%rip), %rsi      # 0x14c41
movb $0x0, %al
callq 0x69d0
jmp 0xc9a2
movq 0xc662(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x82ab(%rip), %rsi      # 0x14c46
movb $0x0, %al
callq 0x69d0
jmp 0xc9a4
jmp 0xc9a6
jmp 0xc9a8
jmp 0xc9aa
jmp 0xc9ac
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xc8af
movq 0xc62c(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x827f(%rip), %rsi      # 0x14c4d
movb $0x0, %al
callq 0x69d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)