LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x14825(%rip), %eax     # 0x1c2ec
movq %rsp, %rdi
movl %eax, (%rdi)
callq 0x7b7d
testl %ebp, %ebp
sete %cl
movl 0x14848(%rip), %eax     # 0x1c324
testb $0x10, %al
sete %dl
orb %cl, %dl
jne 0x7af8
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x79cb
movl 0x1482c(%rip), %eax     # 0x1c324
testb $0x8, %al
jne 0x7b15
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7bb4
leaq 0x8b38(%rip), %r15      # 0x10654
pushq $0x2
popq %r12
pushq $0xd
popq %rbp
testq %rbx, %rbx
je 0x7b6e
cmpb $0xd, (%r14)
jne 0x7b3a
leaq 0x1(%r14), %r13
movq %r15, %rdi
movq %r12, %rsi
jmp 0x7b5b
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6130
leaq (%r14,%rbx), %r13
testq %rax, %rax
cmovneq %rax, %r13
movq %r13, %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x7bb4
movq %r14, %rax
movq %r13, %r14
addq %rax, %rbx
subq %r13, %rbx
jmp 0x7b23
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x14769(%rip), %eax     # 0x1c2ec
testl %eax, %eax
jle 0x7bb3
pushq %rax
movl (%rdi), %ecx
movl %ecx, %esi
sarl $0x1f, %esi
andl 0x108bb(%rip), %esi     # 0x18450
addl %ecx, %esi
cmpl %eax, %esi
cmovgel %eax, %esi
subl %esi, %eax
movl %eax, 0x14748(%rip)     # 0x1c2ec
negl %esi
xorl %edi, %edi
callq 0x840e
popq %rax
jmp 0x849c
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq 0x10706(%rip), %xmm0    # 0x18450
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
leaq 0x8(%rsp), %rdx
movd %xmm0, (%rdx)
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
movl 0x145ee(%rip), %edi     # 0x1c354
movl $0x5414, %esi           # imm = 0x5414
xorl %eax, %eax
callq 0x6110
testl %eax, %eax
js 0x7d7c
addq $0x10, %rsp
popq %rbx
retq
movq 0xf26d(%rip), %rax      # 0x16ff0
movq (%rax), %rbx
callq 0x66e0
movl (%rax), %edi
callq 0x6570
leaq 0x88be(%rip), %rsi      # 0x10657
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x69d0
jmp 0x7d76
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl 0x10693(%rip), %ecx     # 0x18450
movl 0x10691(%rip), %edx     # 0x18454
decl %edx
movq 0x1068c(%rip), %rsi     # 0x18458
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpl $0x2, %ecx
movl $0x1, %r8d
cmovll %r8d, %ecx
decl %ecx
shlq $0x4, %rdx
addq $0x10, %rdx
xorl %r9d, %r9d
cmpq %rcx, %r9
je 0x7e19
xorl %r10d, %r10d
leaq 0x10(%r10), %r11
cmpq %r11, %rdx
je 0x7e11
movq (%rsi,%r9,8), %rbx
movzwl 0x4(%rbx,%r10), %ebx
movq %r11, %r10
testl %edi, %ebx
je 0x7df5
jmp 0x7e16
incq %r9
jmp 0x7ded
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x10629(%rip), %eax     # 0x18450
xorl %r14d, %r14d
pushq $0x1
popq %rbp
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jge 0x7e88
movl 0x10616(%rip), %ecx     # 0x18454
movq 0x10613(%rip), %rdx     # 0x18458
cmpl $0x2, %ecx
cmovll %ebp, %ecx
decl %ecx
shlq $0x4, %rcx
addq $0x10, %rcx
xorl %esi, %esi
leaq 0x10(%rsi), %rdi
cmpq %rdi, %rcx
je 0x7e83
movq (%rdx,%r14,8), %r8
movzwl 0x4(%r8,%rsi), %r8d
movq %rdi, %rsi
testl %ebx, %r8d
je 0x7e57
movl %r14d, %edi
movl %r14d, %esi
callq 0x6f57
movl 0x105cd(%rip), %eax     # 0x18450
incq %r14
jmp 0x7e2d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0xf2b4(%rip), %rax      # 0x175bc
movl (%rax), %eax
leaq 0xf2af(%rip), %rcx      # 0x175c0
movl (%rcx), %ecx
andl $0x0, 0x13fde(%rip)     # 0x1c2f8
andw $0x0, 0x13fda(%rip)     # 0x1c2fc
movl %eax, 0x13fd8(%rip)     # 0x1c300
movl %ecx, 0x13fd6(%rip)     # 0x1c304
andq $0x0, 0x13fd2(%rip)     # 0x1c308
movb $0x0, 0x13fd3(%rip)     # 0x1c310
movq 0x13ff4(%rip), %rdi     # 0x1c338
movslq 0x10109(%rip), %rdx     # 0x18454
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60b0
leaq 0xf25b(%rip), %rax      # 0x175b8
movl (%rax), %ecx
movq 0x13fd2(%rip), %rdx     # 0x1c338
cmpl 0x100e8(%rip), %ecx     # 0x18454
jae 0x837b
movl %ecx, %esi
movl $0x1, (%rdx,%rsi,4)
addl (%rax), %ecx
jmp 0x8366
andl $0x0, 0x13f9a(%rip)     # 0x1c31c
movl 0x100c8(%rip), %eax     # 0x18450
decl %eax
movl %eax, 0x13f90(%rip)     # 0x1c320
movl $0x41, 0x13f8a(%rip)    # 0x1c324
movq $0x3030303, 0x13f87(%rip) # imm = 0x3030303
pushq $0x2
popq %rbx
leaq 0x162c1(%rip), %r14     # 0x1e670
subl $0x1, %ebx
jb 0x8406
xorl %edi, %edi
xorl %esi, %esi
callq 0x8818
movl 0x13f61(%rip), %eax     # 0x1c324
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rax
movups 0x13f30(%rip), %xmm0    # 0x1c304
movups %xmm0, 0xc(%rax,%r14)
movups 0x13f17(%rip), %xmm0    # 0x1c2f8
movups %xmm0, (%rax,%r14)
movl 0x10068(%rip), %edx     # 0x18454
decl %edx
movl 0x1005c(%rip), %ecx     # 0x18450
decl %ecx
xorl %edi, %edi
xorl %esi, %esi
callq 0x8883
callq 0x89a8
jmp 0x83af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $-0x1, 0x10027(%rip)    # 0x1843c
je 0x849b
movl 0x1000f(%rip), %ecx     # 0x18430
cmpl %edi, %ecx
setge %dl
movl 0x13ef4(%rip), %eax     # 0x1c320
cmpl %eax, %ecx
setle %cl
andb %dl, %cl
movl 0xffff(%rip), %edx      # 0x18438
cmpl %edi, %edx
setl %dil
cmpl %eax, %edx
setg %dl
orb %dil, %dl
cmpb %dl, %cl
je 0x6e36
testb %cl, %cl
je 0x849b
movl 0xffe7(%rip), %ecx      # 0x18440
addl %esi, %ecx
movl %ecx, 0xffdf(%rip)      # 0x18440
addl 0xffe1(%rip), %esi      # 0x18448
movl %esi, 0xffdb(%rip)      # 0x18448
movl 0x13ea9(%rip), %edx     # 0x1c31c
cmpl %edx, %ecx
jl 0x6e36
cmpl %eax, %ecx
setg %cl
cmpl %edx, %esi
setl %dl
cmpl %eax, %esi
setg %al
orb %cl, %al
orb %dl, %al
cmpb $0x1, %al
je 0x6e36
jmp 0x6e5f
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
movl %eax, %esi
sarl $0x1f, %esi
andl 0xff98(%rip), %esi      # 0x18450
addl %eax, %esi
movl 0x13e2c(%rip), %eax     # 0x1c2ec
movl $0x7d0, %ecx            # imm = 0x7D0
subl %esi, %ecx
cmpl %ecx, %eax
jle 0x84cc
retq
pushq %rax
addl %esi, %eax
movl %eax, 0x13e17(%rip)     # 0x1c2ec
xorl %edi, %edi
callq 0x840e
popq %rax
jmp 0x849c
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: externalpipe
void
externalpipe(const Arg *arg)
{
	int to[2];
	char buf[UTF_SIZ];
	void (*oldsigpipe)(int);
	Glyph *bp, *end;
	int lastpos, n, newline;

	if (pipe(to) == -1)
		return;

	switch (fork()) {
	case -1:
		close(to[0]);
		close(to[1]);
		return;
	case 0:
		dup2(to[0], STDIN_FILENO);
		close(to[0]);
		close(to[1]);
		execvp(((char **)arg->v)[0], (char **)arg->v);
		fprintf(stderr, "st: execvp %s\n", ((char **)arg->v)[0]);
		perror("failed");
		exit(0);
	}

	close(to[0]);
	/* ignore sigpipe for now, in case child exists early */
	oldsigpipe = signal(SIGPIPE, SIG_IGN);
	newline = 0;
	for (n = 0; n < term.row; n++) {
		bp = term.line[n];
		lastpos = MIN(tlinelen(n) + 1, term.col) - 1;
		if (lastpos < 0)
			break;
		end = &bp[lastpos + 1];
		for (; bp < end; ++bp)
			if (xwrite(to[1], buf, utf8encode(bp->u, buf)) < 0)
				break;
		if ((newline = term.line[n][lastpos].mode & ATTR_WRAP))
			continue;
		if (xwrite(to[1], "\n", 1) < 0)
			break;
		newline = 0;
	}
	if (newline)
		(void)xwrite(to[1], "\n", 1);
	close(to[1]);
	/* restore */
	signal(SIGPIPE, oldsigpipe);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x64f0
cmpl $-0x1, %eax
je 0x863e
callq 0x6910
movl (%rsp), %edi
cmpl $-0x1, %eax
je 0x8601
testl %eax, %eax
je 0x864d
callq 0x60f0
pushq $0xd
popq %rdi
pushq $0x1
popq %rsi
callq 0x6060
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x14(%rsp), %r12
xorl %ebp, %ebp
movslq 0xfeef(%rip), %rax      # 0x18450
cmpq %rax, %r15
jge 0x8611
movl %r15d, %edi
callq 0x7303
incl %eax
movl 0xfeda(%rip), %ecx      # 0x18454
cmpl %ecx, %eax
cmovgel %ecx, %eax
testl %eax, %eax
jle 0x8611
movq 0xfeca(%rip), %rcx      # 0x18458
movq (%rcx,%r15,8), %r13
movl %eax, %ebx
shlq $0x4, %rbx
leaq (%rbx,%r13), %r14
cmpq %r14, %r13
jae 0x85c7
movl 0x4(%rsp), %ebp
movl (%r13), %edi
movq %r12, %rsi
callq 0x6ce2
movl %ebp, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x86a1
addq $0x10, %r13
testq %rax, %rax
jns 0x859c
movq 0xfe8a(%rip), %rax      # 0x18458
movq (%rax,%r15,8), %rax
movzwl -0xc(%rax,%rbx), %ebp
andl $0x100, %ebp            # imm = 0x100
jne 0x85f9
movl 0x4(%rsp), %edi
leaq 0x806b(%rip), %rsi      # 0x10655
pushq $0x1
popq %rdx
callq 0x86a1
xorl %ebp, %ebp
testq %rax, %rax
js 0x8628
incq %r15
jmp 0x855a
callq 0x60f0
movl 0x4(%rsp), %edi
callq 0x60f0
jmp 0x863e
testl %ebp, %ebp
je 0x8628
movl 0x4(%rsp), %edi
leaq 0x8035(%rip), %rsi      # 0x10655
pushq $0x1
popq %rdx
callq 0x86a1
movl 0x4(%rsp), %edi
callq 0x60f0
pushq $0xd
popq %rdi
movq 0x8(%rsp), %rsi
callq 0x6060
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
callq 0x6070
movl (%rsp), %edi
callq 0x60f0
movl 0x4(%rsp), %edi
callq 0x60f0
movq (%rbx), %rsi
movq (%rsi), %rdi
callq 0x6190
movq 0xe979(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
movq (%rbx), %rax
movq (%rax), %rdx
leaq 0x8002(%rip), %rsi      # 0x10689
xorl %eax, %eax
callq 0x69d0
leaq 0x82cd(%rip), %rdi      # 0x10962
callq 0x69a0
xorl %edi, %edi
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, %r15
testq %r15, %r15
je 0x86d5
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x69e0
testq %rax, %rax
js 0x86d2
subq %rax, %r15
addq %rax, %r14
jmp 0x86b3
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x7fa7(%rip), %rdi      # 0x10698
leaq 0x8c20(%rip), %rsi      # 0x11318
callq 0x6a10
testq %rax, %rax
je 0x8780
movq %rax, %r14
leaq 0xf(%rsp), %rdi
pushq $0x9
popq %rsi
movq %rax, %rdx
callq 0x6320
movq %rax, %rbx
movq %r14, %rdi
callq 0x6440
testq %rbx, %rbx
je 0x8780
movzbl (%rbx), %eax
testl %eax, %eax
je 0x8780
cmpl $0x2d, %eax
je 0x8780
movq %rbx, %rdi
callq 0x6410
cmpq $0x7, %rax
ja 0x8780
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x6a20
cmpq $-0x1, %rax
je 0x8780
movq (%rsp), %rcx
movzbl (%rcx), %ecx
cmpl $0xa, %ecx
je 0x8763
testl %ecx, %ecx
jne 0x8780
leaq 0xb(%rsp), %rbx
movl %eax, %edi
movq %rbx, %rsi
callq 0x6ce2
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7aae
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movl $0x0, %ecx
testl %edi, %edi
js 0x87f0
movl 0xfc67(%rip), %ecx      # 0x18450
decl %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
testl %esi, %esi
js 0x8801
movl 0xfc56(%rip), %eax      # 0x18450
decl %eax
cmpl %esi, %eax
cmovgel %esi, %eax
cmpl %eax, %ecx
movl %eax, %edx
cmovgl %ecx, %edx
cmovll %ecx, %eax
movl %eax, 0x13b0b(%rip)     # 0x1c31c
movl %edx, 0x13b09(%rip)     # 0x1c320
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movb 0x13af2(%rip), %dl      # 0x1c310
movl 0x13af8(%rip), %eax     # 0x1c31c
movl 0x13af6(%rip), %ecx     # 0x1c320
movl 0xfc1f(%rip), %r8d      # 0x18450
movl %edx, %r9d
andb $-0x2, %r9b
movb %r9b, 0x13ad1(%rip)     # 0x1c310
xorl %r9d, %r9d
movl $0x0, %r10d
testl %edi, %edi
js 0x885d
movl 0xfc01(%rip), %r10d     # 0x18454
decl %r10d
cmpl %edi, %r10d
cmovgel %edi, %r10d
decl %r8d
testb $0x2, %dl
cmovel %r8d, %ecx
cmovel %r9d, %eax
movl %r10d, 0x13a96(%rip)    # 0x1c308
cmpl %esi, %ecx
cmovgel %esi, %ecx
cmpl %esi, %eax
cmovgl %eax, %ecx
movl %ecx, 0x13a8a(%rip)     # 0x1c30c
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: tclearregion
void
tclearregion(int x1, int y1, int x2, int y2)
{
	int x, y, temp;
	Glyph *gp;

	if (x1 > x2)
		temp = x1, x1 = x2, x2 = temp;
	if (y1 > y2)
		temp = y1, y1 = y2, y2 = temp;

	LIMIT(x1, 0, term.col-1);
	LIMIT(x2, 0, term.col-1);
	LIMIT(y1, 0, term.row-1);
	LIMIT(y2, 0, term.row-1);

	for (y = y1; y <= y2; y++) {
		term.dirty[y] = 1;
		for (x = x1; x <= x2; x++) {
			gp = &term.line[y][x];
			if (selected(x, y))
				selclear();
			gp->fg = term.c.attr.fg;
			gp->bg = term.c.attr.bg;
			gp->mode = 0;
			gp->u = ' ';
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, %edi
movl %edx, %r8d
cmovgl %edi, %r8d
cmovll %edi, %edx
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
cmovgl %esi, %ecx
testl %edx, %edx
js 0x88c2
movl 0xfba3(%rip), %esi      # 0x18454
decl %esi
cmpl %esi, %edx
cmovll %edx, %esi
movslq %esi, %rdx
movq %rdx, 0x8(%rsp)
jmp 0x88cb
movq $0x0, 0x8(%rsp)
testl %r8d, %r8d
js 0x88e4
movl 0xfb7e(%rip), %edx      # 0x18454
decl %edx
cmpl %edx, %r8d
cmovll %r8d, %edx
movslq %edx, %r12
jmp 0x88e7
xorl %r12d, %r12d
testl %eax, %eax
js 0x88fd
movl 0xfb5f(%rip), %edx      # 0x18450
decl %edx
cmpl %edx, %eax
cmovll %eax, %edx
movslq %edx, %rbx
jmp 0x88ff
xorl %ebx, %ebx
testl %ecx, %ecx
js 0x8919
movl 0xfb47(%rip), %eax      # 0x18450
decl %eax
cmpl %eax, %ecx
cmovll %ecx, %eax
cltq
movq %rax, 0x10(%rsp)
jmp 0x8922
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %r15
shlq $0x4, %r15
orq $0x8, %r15
cmpq 0x10(%rsp), %rbx
jg 0x8999
movq 0x139b3(%rip), %rax     # 0x1c2f0
movl $0x1, (%rax,%rbx,4)
movq %r15, %rbp
movq 0x8(%rsp), %r14
cmpq %r12, %r14
jg 0x8994
movq 0xfb00(%rip), %rax      # 0x18458
movq (%rax,%rbx,8), %r13
movl %r14d, %edi
movl %ebx, %esi
callq 0x707f
testl %eax, %eax
je 0x896f
callq 0x6e36
movq 0x1398a(%rip), %rax     # 0x1c300
movq %rax, (%r13,%rbp)
andw $0x0, -0x4(%r13,%rbp)
movl $0x20, -0x8(%r13,%rbp)
incq %r14
addq $0x10, %rbp
jmp 0x894c
incq %rbx
jmp 0x892f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x13955(%rip), %eax     # 0x1c324
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rcx
leaq 0x15c90(%rip), %rax     # 0x1e670
addq %rcx, %rax
testl %edi, %edi
je 0x8a07
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0x1390f(%rip)    # 0x1c304
movups %xmm0, 0x138fc(%rip)    # 0x1c2f8
movl 0x10(%rax), %edi
movl 0x14(%rax), %esi
jmp 0x8818
movups 0x138f6(%rip), %xmm0    # 0x1c304
movups %xmm0, 0xc(%rax)
movups 0x138df(%rip), %xmm0    # 0x1c2f8
movups %xmm0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rdx
movq %rdi, %rsi
movl 0xe5b0(%rip), %edi      # 0x17580
cmpl $-0x1, %edi
je 0x8fe4
pushq %rax
callq 0x86a1
testq %rax, %rax
js 0x8fe5
addq $0x8, %rsp
retq
leaq 0x7841(%rip), %rdi      # 0x1082d
callq 0x69a0
movl 0xe589(%rip), %edi      # 0x17580
callq 0x60f0
orl $-0x1, 0xe57d(%rip)     # 0x17580
jmp 0x8fe0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xf443(%rip), %rax      # 0x18458
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x7303
movl 0xf42d(%rip), %ecx      # 0x18454
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r15
addq $-0x10, %r15
cmpq %r15, %r14
jne 0x905e
cmpl $0x20, (%r14)
jne 0x905e
leaq 0x7608(%rip), %rdi      # 0x10655
pushq $0x1
popq %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8fc4
leaq 0xc(%rsp), %rbx
cmpq %r15, %r14
ja 0x9046
movl (%r14), %edi
movq %rbx, %rsi
callq 0x6ce2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8fc4
addq $0x10, %r14
jmp 0x9063
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xfffd, (%rsi)         # imm = 0xFFFD
testq %rdx, %rdx
je 0x9112
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movsbl (%rdi), %edi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0xa29a
movl %eax, %ebp
movq (%rbx), %r14
leaq -0x1(%r14), %rax
cmpq $0x3, %rax
ja 0x9107
movq %r13, (%rsp)
decq %r15
cmpq %r15, %rax
cmovbq %rax, %r15
negq %r15
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %r13
leaq (%r15,%rbx), %rax
cmpq $0x1, %rax
je 0x910d
movsbl (%r12,%rbx), %edi
movq %r13, %rsi
callq 0xa29a
cmpq $0x0, 0x8(%rsp)
jne 0x9117
shll $0x6, %ebp
orl %eax, %ebp
incq %rbx
jmp 0x90de
pushq $0x1
popq %r14
jmp 0x912a
cmpq %r14, %rbx
jae 0x911c
xorl %r14d, %r14d
jmp 0x912a
movq %rbx, %r14
jmp 0x912a
movq (%rsp), %rdi
movl %ebp, (%rdi)
movq %r14, %rsi
callq 0x6d55
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl %dil, %ecx
xorl %edx, %edx
leaq 0x61b2(%rip), %rdi      # 0x10459
leaq 0x61a6(%rip), %r8       # 0x10454
cmpq $0x5, %rdx
je 0xa2cd
movzbl (%rdx,%rdi), %eax
movl %eax, %r9d
andl %ecx, %r9d
movzbl (%rdx,%r8), %r10d
cmpl %r10d, %r9d
je 0xa2d7
incq %rdx
jmp 0xa2ae
movq $0x5, (%rsi)
xorl %eax, %eax
retq
movq %rdx, (%rsi)
notl %eax
andl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebp
movl 0x12022(%rip), %ebx     # 0x1c30c
cmpl 0x12030(%rip), %ebx     # 0x1c320
jne 0xa304
movl 0x12024(%rip), %edi     # 0x1c31c
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0xacae
jmp 0xa306
incl %ebx
xorl %edi, %edi
testl %ebp, %ebp
jne 0xa312
movl 0x11ff6(%rip), %edi     # 0x1c308
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8818
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: tsetchar
void
tsetchar(Rune u, const Glyph *attr, int x, int y)
{
	static const char *vt100_0[62] = { /* 0x41 - 0x7e */
		"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
		0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
		0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
		0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
		"◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
		"␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
		"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
		"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
	};

	/*
	 * The table is proudly stolen from rxvt.
	 */
	if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
	   BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
		utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);

	if (term.line[y][x].mode & ATTR_WIDE) {
		if (x+1 < term.col) {
			term.line[y][x+1].u = ' ';
			term.line[y][x+1].mode &= ~ATTR_WDUMMY;
		}
	} else if (term.line[y][x].mode & ATTR_WDUMMY) {
		term.line[y][x-1].u = ' ';
		term.line[y][x-1].mode &= ~ATTR_WIDE;
	}

	term.dirty[y] = 1;
	term.line[y][x] = *attr;
	term.line[y][x].u = u;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %edi, 0x4(%rsp)
addl $-0x41, %edi
cmpl $0x3d, %edi
ja 0xa36e
leaq 0xe117(%rip), %rax      # 0x18450
movslq 0x11ff0(%rip), %rcx     # 0x1c330
cmpb $0x0, 0x3edc(%rcx,%rax)
jne 0xa36e
movl %edi, %eax
leaq -0x7(%rax), %rcx
cmpq $0x17, %rcx
jb 0xa36e
leaq 0xacf3(%rip), %rcx      # 0x15050
movq (%rcx,%rax,8), %rdi
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x9084
movq 0xe0e3(%rip), %rcx      # 0x18458
movslq %ebp, %rax
movq (%rcx,%rax,8), %rdx
movslq %ebx, %rcx
shlq $0x4, %rcx
movzwl 0x4(%rdx,%rcx), %esi
btl $0x9, %esi
jb 0xa39c
btl $0xa, %esi
jae 0xa3bd
decl %ebx
movw $0xfdff, %si            # imm = 0xFDFF
jmp 0xa3aa
incl %ebx
movw $0xfbff, %si            # imm = 0xFBFF
cmpl 0xe0ac(%rip), %ebx      # 0x18454
jge 0xa3bd
movslq %ebx, %rdi
shlq $0x4, %rdi
movl $0x20, (%rdx,%rdi)
andw %si, 0x4(%rdx,%rdi)
movq 0x11f2c(%rip), %rsi     # 0x1c2f0
movl $0x1, (%rsi,%rax,4)
movups 0x11f26(%rip), %xmm0    # 0x1c2f8
movups %xmm0, (%rdx,%rcx)
movl 0x4(%rsp), %edx
movq 0xe077(%rip), %rsi      # 0x18458
movq (%rsi,%rax,8), %rax
movl %edx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x11f13(%rip), %eax     # 0x1c308
testl %edi, %edi
jle 0xa42b
movl 0xe055(%rip), %ecx      # 0x18454
movq 0x11f32(%rip), %rdx     # 0x1c338
cmpl %ecx, %eax
jae 0xa460
subl $0x1, %edi
jb 0xa460
movl %eax, %esi
incq %rsi
cmpq %rcx, %rsi
jae 0xa427
incl %eax
cmpl $0x0, (%rdx,%rsi,4)
leaq 0x1(%rsi), %rsi
je 0xa414
jmp 0xa406
movl %ecx, %eax
jmp 0xa406
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xa460
movq 0x11ef7(%rip), %rcx     # 0x1c338
testl %edi, %edi
je 0xa460
incl %edi
decl %eax
movl %eax, %edx
subl $0x1, %eax
jb 0xa45e
movl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
movl %eax, %edx
je 0xa44b
incl %eax
jmp 0xa441
xorl %eax, %eax
movl 0xdfee(%rip), %ecx      # 0x18454
decl %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, 0x11e95(%rip)     # 0x1c308
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x9f, %edi
je 0xaa1f
movl %edi, %ebx
cmpl $0x9d, %edi
je 0xaa17
cmpl $0x9e, %ebx
je 0xaa1b
cmpl $0x90, %ebx
jne 0xaa21
movb $0x50, %bl
jmp 0xaa21
movb $0x5d, %bl
jmp 0xaa21
movb $0x5e, %bl
jmp 0xaa21
movb $0x5f, %bl
movq 0x13948(%rip), %rdi     # 0x1e370
movl $0x200, %esi            # imm = 0x200
callq 0x6c8e
andq $0x0, 0x1392e(%rip)     # 0x1e368
movq %rax, 0x1392f(%rip)     # 0x1e370
movq $0x200, 0x1392c(%rip) # imm = 0x200
leaq 0x1392d(%rip), %rdi     # 0x1e380
movl $0x90, %edx
xorl %esi, %esi
callq 0x60b0
movb %bl, 0x13903(%rip)      # 0x1e368
orb $0x4, 0x118bc(%rip)     # 0x1c328
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
testl %edx, %edx
cmovnel %edi, %r14d
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movl %r14d, %edi
callq 0xb512
testl %eax, %eax
jne 0xab0c
testl %ebx, %ebx
leaq 0x6bf7(%rip), %rax      # 0x1169e
leaq 0x5e82(%rip), %rcx      # 0x10930
cmoveq %rax, %rcx
movzbl 0xf(%rsp), %r9d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
subq $0x8, %rsp
leaq 0x5e3a(%rip), %rdx      # 0x10909
leaq 0x18(%rsp), %rdi
pushq $0x20
popq %rsi
movl %ebp, %r8d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
pushq %r9
callq 0x60c0
addq $0x30, %rsp
cmpl $0x20, %eax
jae 0xab3d
movl %eax, %esi
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x7aae
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
movq 0xc4db(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq 0x5de6(%rip), %rax      # 0x10905
leaq 0x5dda(%rip), %rdx      # 0x10900
cmoveq %rax, %rdx
leaq 0x5daa(%rip), %rsi      # 0x108db
movl %r14d, %ecx
xorl %eax, %eax
callq 0x69d0
jmp 0xab03
testl %eax, %eax
leaq 0x5e13(%rip), %rax      # 0x10959
leaq 0x5e1c(%rip), %rdx      # 0x10969
cmovsq %rax, %rdx
testl %ebx, %ebx
movq 0xc496(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq 0x5da1(%rip), %rax      # 0x10905
leaq 0x5d95(%rip), %rcx      # 0x10900
cmoveq %rax, %rcx
leaq 0x5dbd(%rip), %rsi      # 0x10933
xorl %eax, %eax
callq 0x69d0
jmp 0xab03
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: csidump
void
csidump(void)
{
	size_t i;
	uint c;

	fprintf(stderr, "ESC[");
	for (i = 0; i < csiescseq.len; i++) {
		c = csiescseq.buf[i] & 0xff;
		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);
		}
	}
	putc('\n', stderr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc41d(%rip), %r12      # 0x16ff0
movq (%r12), %rcx
leaq 0x5de4(%rip), %rdi      # 0x109c2
pushq $0x4
popq %rbx
pushq $0x1
popq %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6950
leaq 0x13819(%rip), %r13     # 0x1e410
xorl %ebp, %ebp
cmpq 0x13a10(%rip), %rbp     # 0x1e610
jae 0xac7a
movzbl (%rbp,%r13), %r15d
callq 0x6460
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r15,2)
movq (%r12), %rcx
je 0xac2c
movl %r15d, %edi
movq %rcx, %rsi
callq 0x6620
incq %rbp
jmp 0xabf9
cmpl $0x1b, %r15d
je 0xac50
cmpl $0xd, %r15d
je 0xac47
cmpl $0xa, %r15d
jne 0xac64
leaq 0x5d3e(%rip), %rdi      # 0x10983
jmp 0xac57
leaq 0x5d3a(%rip), %rdi      # 0x10988
jmp 0xac57
leaq 0x5d36(%rip), %rdi      # 0x1098d
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6950
jmp 0xac27
movq %rcx, %rdi
leaq 0x5d24(%rip), %rsi      # 0x10992
movl %r15d, %edx
xorl %eax, %eax
callq 0x69d0
jmp 0xac27
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6620
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: tscrollup
void
tscrollup(int orig, int n, int copyhist)
{
	int i;
	Line temp;

	LIMIT(n, 0, term.bot-orig+1);

	if (copyhist) {
		term.histi = (term.histi + 1) % HISTSIZE;
		temp = term.hist[term.histi];
		term.hist[term.histi] = term.line[orig];
		term.line[orig] = temp;
	}

	tclearregion(0, orig, term.col-1, orig+n-1);
	tsetdirt(orig+n, term.bot);

	for (i = orig; i <= term.bot-n; i++) {
		temp = term.line[i];
		term.line[i] = term.line[i+n];
		term.line[i+n] = temp;
	}

	selscroll(orig, -n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
js 0xacd1
movl 0x1165e(%rip), %r14d    # 0x1c320
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xacd4
xorl %r14d, %r14d
testl %edx, %edx
je 0xad1d
leaq 0xd771(%rip), %rcx      # 0x18450
movl 0x11603(%rip), %eax     # 0x1c2e8
incl %eax
movl $0x7d0, %esi            # imm = 0x7D0
cltd
idivl %esi
movl %edx, 0x115f3(%rip)     # 0x1c2e8
movslq %edx, %rax
movq 0x18(%rcx,%rax,8), %rdx
movq 0xd754(%rip), %rsi      # 0x18458
movslq %ebx, %r15
movq (%rsi,%r15,8), %rsi
movq %rsi, 0x18(%rcx,%rax,8)
movq 0xd741(%rip), %rax      # 0x18458
movq %rdx, (%rax,%r15,8)
jmp 0xad20
movslq %ebx, %r15
movl 0xd72e(%rip), %edx      # 0x18454
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x8883
movl 0x115df(%rip), %esi     # 0x1c320
movl %ebp, %edi
callq 0x6f57
movslq 0x115d1(%rip), %rax     # 0x1c320
movslq %r14d, %rcx
subq %rcx, %rax
shlq $0x3, %rcx
cmpq %rax, %r15
jg 0xad88
movq 0xd6f3(%rip), %rdx      # 0x18458
leaq (%rdx,%r15,8), %rsi
movq (%rdx,%r15,8), %rdi
movq (%rcx,%rsi), %rsi
movq %rsi, (%rdx,%r15,8)
movq 0xd6dc(%rip), %rdx      # 0x18458
addq %rcx, %rdx
movq %rdi, (%rdx,%r15,8)
incq %r15
jmp 0xad59
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x840e
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: tscrolldown
void
tscrolldown(int orig, int n, int copyhist)
{
	int i;
	Line temp;

	LIMIT(n, 0, term.bot-orig+1);

	if (copyhist) {
		term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE;
		temp = term.hist[term.histi];
		term.hist[term.histi] = term.line[term.bot];
		term.line[term.bot] = temp;
	}

	tsetdirt(orig, term.bot-n);
	tclearregion(0, term.bot-n+1, term.col-1, term.bot);

	for (i = term.bot; i >= orig+n; i--) {
		temp = term.line[i];
		term.line[i] = term.line[i-n];
		term.line[i-n] = temp;
	}

	selscroll(orig, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movl %edi, %ebx
movslq 0x11572(%rip), %rsi     # 0x1c320
testl %eax, %eax
js 0xadc4
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0xadc7
xorl %r14d, %r14d
testl %edx, %edx
je 0xae0e
leaq 0xd67e(%rip), %rcx      # 0x18450
movl $0x7cf, %eax            # imm = 0x7CF
addl 0x1150b(%rip), %eax     # 0x1c2e8
movl $0x7d0, %edi            # imm = 0x7D0
cltd
idivl %edi
movl %edx, 0x114fd(%rip)     # 0x1c2e8
movslq %edx, %rax
movq 0x18(%rcx,%rax,8), %rdx
movq 0xd65e(%rip), %rdi      # 0x18458
movq (%rdi,%rsi,8), %rdi
movq %rdi, 0x18(%rcx,%rax,8)
movq 0xd64e(%rip), %rax      # 0x18458
movq %rdx, (%rax,%rsi,8)
subl %r14d, %esi
movl %ebx, %edi
callq 0x6f57
movl 0x11502(%rip), %ecx     # 0x1c320
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0xd629(%rip), %edx      # 0x18454
decl %edx
xorl %edi, %edi
callq 0x8883
movslq 0x114e5(%rip), %rax     # 0x1c320
leal (%r14,%rbx), %ecx
movslq %ecx, %rcx
movslq %r14d, %rdx
shlq $0x3, %rdx
negq %rdx
cmpq %rcx, %rax
jl 0xae7b
movq 0xd600(%rip), %rsi      # 0x18458
leaq (%rsi,%rax,8), %rdi
movq (%rsi,%rax,8), %r8
movq (%rdx,%rdi), %rdi
movq %rdi, (%rsi,%rax,8)
movq 0xd5e9(%rip), %rsi      # 0x18458
addq %rdx, %rsi
movq %r8, (%rsi,%rax,8)
decq %rax
jmp 0xae4c
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x840e
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: tdefcolor
int32_t
tdefcolor(const int *attr, int *npar, int l)
{
	int32_t idx = -1;
	uint r, g, b;

	switch (attr[*npar + 1]) {
	case 2: /* direct color in RGB space */
		if (*npar + 4 >= l) {
			fprintf(stderr,
				"erresc(38): Incorrect number of parameters (%d)\n",
				*npar);
			break;
		}
		r = attr[*npar + 2];
		g = attr[*npar + 3];
		b = attr[*npar + 4];
		*npar += 4;
		if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
			fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
				r, g, b);
		else
			idx = TRUECOLOR(r, g, b);
		break;
	case 5: /* indexed color */
		if (*npar + 2 >= l) {
			fprintf(stderr,
				"erresc(38): Incorrect number of parameters (%d)\n",
				*npar);
			break;
		}
		*npar += 2;
		if (!BETWEEN(attr[*npar], 0, 255))
			fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
		else
			idx = attr[*npar];
		break;
	case 0: /* implemented defined (only foreground) */
	case 1: /* transparent */
	case 3: /* direct color in CMY space */
	case 4: /* direct color in CMYK space */
	default:
		fprintf(stderr,
		        "erresc(38): gfx attr %d unknown\n", attr[*npar]);
		break;
	}

	return idx;
}

// Assembly:
pushq %rax
movslq (%rdi), %rdx
leaq 0x13282(%rip), %r8      # 0x1e410
movl 0x210(%r8,%rdx,4), %eax
cmpl $0x5, %eax
je 0xb1fb
cmpl $0x2, %eax
jne 0xb23b
leal 0x4(%rdx), %r9d
cmpl %esi, %r9d
jge 0xb228
movl 0x214(%r8,%rdx,4), %eax
movl 0x218(%r8,%rdx,4), %ecx
movl 0x21c(%r8,%rdx,4), %r8d
movl %r9d, (%rdi)
cmpl $0xff, %eax
ja 0xb260
cmpl $0xff, %ecx
ja 0xb260
cmpl $0x100, %r8d            # imm = 0x100
jae 0xb260
shll $0x10, %eax
shll $0x8, %ecx
orl %eax, %ecx
leal (%r8,%rcx), %eax
addl $0x1000000, %eax        # imm = 0x1000000
jmp 0xb25e
leal 0x2(%rdx), %eax
cmpl %esi, %eax
jge 0xb228
movl %eax, (%rdi)
movl 0x214(%r8,%rdx,4), %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xb25e
movq 0xbdd6(%rip), %rcx      # 0x16ff0
movq (%rcx), %rdi
leaq 0x586a(%rip), %rsi      # 0x10a8e
movl %eax, %edx
jmp 0xb254
movq 0xbdc1(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq 0x5802(%rip), %rsi      # 0x10a3b
jmp 0xb254
movq 0xbdae(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
movl 0x20c(%r8,%rdx,4), %edx
leaq 0x5852(%rip), %rsi      # 0x10aa6
xorl %eax, %eax
callq 0x69d0
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0xbd89(%rip), %rdx      # 0x16ff0
movq (%rdx), %rdi
leaq 0x57fb(%rip), %rsi      # 0x10a6c
movl %eax, %edx
xorl %eax, %eax
callq 0x69d0
jmp 0xb25b
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: clipcopy
void
clipcopy(const Arg *dummy)
{
	Atom clipboard;

	free(xsel.clipboard);
	xsel.clipboard = NULL;

	if (xsel.primary != NULL) {
		xsel.clipboard = xstrdup(xsel.primary);
		clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
		XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
	}
}

// Assembly:
pushq %rax
movq 0x13722(%rip), %rdi     # 0x1e9a8
callq 0x63d0
andq $0x0, 0x13715(%rip)     # 0x1e9a8
movq 0x13706(%rip), %rdi     # 0x1e9a0
testq %rdi, %rdi
je 0xb2d9
callq 0x6cb8
movq %rax, 0x136fd(%rip)     # 0x1e9a8
movq 0x1354e(%rip), %rdi     # 0x1e800
leaq 0x5cd8(%rip), %rsi      # 0x10f91
xorl %edx, %edx
callq 0x6860
movq 0x13539(%rip), %rdi     # 0x1e800
movq 0x13542(%rip), %rdx     # 0x1e810
movq %rax, %rsi
xorl %ecx, %ecx
popq %rax
jmp 0x6740
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: setsel
void
setsel(char *str, Time t)
{
	if (!str)
		return;

	free(xsel.primary);
	xsel.primary = str;

	XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
	if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)
		selclear();
}

// Assembly:
testq %rdi, %rdi
je 0xb342
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x136ab(%rip), %rdi     # 0x1e9a0
callq 0x63d0
movq %r14, 0x1369f(%rip)     # 0x1e9a0
movq 0x134f8(%rip), %rdi     # 0x1e800
movq 0x13501(%rip), %rdx     # 0x1e810
pushq $0x1
popq %r14
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6740
movq 0x134db(%rip), %rdi     # 0x1e800
movq %r14, %rsi
callq 0x6a40
cmpq 0x134dc(%rip), %rax     # 0x1e810
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
jne 0x6e36
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xloadcols
void
xloadcols(void)
{
	int i;
	static int loaded;
	Color *cp;

	if (loaded) {
		for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
			XFreeColors(xw.dpy, xw.cmap, &cp->pixel, 1, 0);
	} else {
		dc.collen = MAX(LEN(colorname), 256);
		dc.col = xmalloc(dc.collen * sizeof(Color));
	}

	for (i = 0; i < dc.collen; i++)
		if (!xloadcolor(i, NULL, &dc.col[i])) {
			if (colorname[i])
				die("could not allocate color '%s'\n", colorname[i]);
			else
				die("could not allocate color %d\n", i);
		}
	loaded = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x1336d(%rip)     # 0x1e6c0
jne 0xb39d
movq 0x1336c(%rip), %rax     # 0x1e6c8
pushq $0x1
popq %rbx
movq %rax, %r14
movq 0x13367(%rip), %rcx     # 0x1e6d0
shlq $0x4, %rcx
addq %rax, %rcx
cmpq %rcx, %r14
jae 0xb3b9
movq 0x13484(%rip), %rdi     # 0x1e800
movq 0x13485(%rip), %rsi     # 0x1e808
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x62a0
addq $0x10, %r14
movq 0x1332d(%rip), %rax     # 0x1e6c8
jmp 0xb362
movq $0x104, 0x13328(%rip) # imm = 0x104
movl $0x1040, %edi           # imm = 0x1040
callq 0x6bcc
movq %rax, 0x1330f(%rip)     # 0x1e6c8
leaq 0xc210(%rip), %r12      # 0x175d0
leaq 0x5a7d(%rip), %rbx      # 0x10e44
leaq 0x5a57(%rip), %r14      # 0x10e25
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, 0x132f5(%rip)     # 0x1e6d0
jbe 0xb424
movq 0x132e4(%rip), %rdx     # 0x1e6c8
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xb435
testl %eax, %eax
jne 0xb417
movq (%r12), %rsi
testq %rsi, %rsi
je 0xb40a
movq %r14, %rdi
xorl %eax, %eax
callq 0x6bf6
jmp 0xb417
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x6bf6
incq %r15
addq $0x10, %r13
addq $0x8, %r12
jmp 0xb3d4
movb $0x1, 0x13295(%rip)     # 0x1e6c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xloadcolor
int
xloadcolor(int i, const char *name, Color *ncolor)
{
	XColor screen, color;

	if (!name) {
		if (BETWEEN(i, 16, 255)) { /* 256 color */
			if (i < 6*6*6+16) { /* same colors as xterm */
				color.red   = sixd_to_16bit( ((i-16)/36)%6 );
				color.green = sixd_to_16bit( ((i-16)/6) %6 );
				color.blue  = sixd_to_16bit( ((i-16)/1) %6 );
			} else { /* greyscale */
				color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16));
				color.green = color.blue = color.red;
			}
			ncolor->red = color.red;
			ncolor->green = color.green;
			ncolor->blue = color.blue;
			return XAllocColor(xw.dpy, xw.cmap, ncolor);
		} else {
			name = colorname[i];
		}
	}

	return XAllocNamedColor(xw.dpy, xw.cmap, name, &screen, ncolor);
}

// Assembly:
movq %rdx, %r8
movq %rsi, %rdx
testq %rsi, %rsi
jne 0xb4bc
leal -0x10(%rdi), %esi
cmpl $0xef, %esi
ja 0xb4ae
cmpl $0xe7, %edi
ja 0xb4dd
movzbl %sil, %ecx
movb $0x24, %dl
movl %ecx, %eax
divb %dl
movzbl %al, %eax
imull $0x2828, %eax, %edx     # imm = 0x2828
movl $0x3737, %edi           # imm = 0x3737
addl %edi, %edx
xorl %r9d, %r9d
cmpl $0x24, %esi
cmovbl %r9d, %edx
movb $0x6, %r10b
movl %ecx, %eax
divb %r10b
movzbl %ah, %esi
movzbl %al, %eax
divb %r10b
movzbl %ah, %ecx
imull $0x2828, %ecx, %eax     # imm = 0x2828
addl %edi, %eax
testb %cl, %cl
cmovel %r9d, %eax
imull $0x2828, %esi, %ecx     # imm = 0x2828
addl %edi, %ecx
testb %sil, %sil
cmovel %r9d, %ecx
jmp 0xb4ed
movslq %edi, %rax
leaq 0xc118(%rip), %rcx      # 0x175d0
movq (%rcx,%rax,8), %rdx
subq $0x18, %rsp
movq 0x13339(%rip), %rdi     # 0x1e800
movq 0x1333a(%rip), %rsi     # 0x1e808
leaq 0x8(%rsp), %rcx
callq 0x6270
addq $0x18, %rsp
retq
imull $0xa0a, %edi, %ecx      # imm = 0xA0A
addl $0xffffeef8, %ecx       # imm = 0xFFFFEEF8
movl %ecx, %eax
movl %ecx, %edx
movw %dx, 0x8(%r8)
movw %ax, 0xa(%r8)
movw %cx, 0xc(%r8)
movq 0x132fd(%rip), %rdi     # 0x1e800
movq 0x132fe(%rip), %rsi     # 0x1e808
movq %r8, %rdx
jmp 0x6850
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xgetcolor
int
xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b)
{
	if (!BETWEEN(x, 0, dc.collen))
		return 1;

	*r = dc.col[x].red >> 8;
	*g = dc.col[x].green >> 8;
	*b = dc.col[x].blue >> 8;

	return 0;
}

// Assembly:
pushq $0x1
popq %rax
testl %edi, %edi
js 0xb551
movl %edi, %edi
cmpq %rdi, 0x131ae(%rip)     # 0x1e6d0
jb 0xb551
movq 0x1319d(%rip), %rax     # 0x1e6c8
shlq $0x4, %rdi
movb 0x9(%rax,%rdi), %al
movb %al, (%rsi)
movq 0x1318c(%rip), %rax     # 0x1e6c8
movb 0xb(%rax,%rdi), %al
movb %al, (%rdx)
movq 0x1317f(%rip), %rax     # 0x1e6c8
movb 0xd(%rax,%rdi), %al
movb %al, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xsetcolorname
int
xsetcolorname(int x, const char *name)
{
	Color ncolor;

	if (!BETWEEN(x, 0, dc.collen))
		return 1;

	if (!xloadcolor(x, name, &ncolor))
		return 1;

	XFreeColors(xw.dpy, xw.cmap, &dc.col[x].pixel, 1, 0);
	dc.col[x] = ncolor;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
pushq $0x1
popq %rbx
testl %edi, %edi
js 0xb5b4
movl %edi, %r14d
cmpq %r14, 0x13166(%rip)     # 0x1e6d0
jb 0xb5b4
leaq 0x8(%rsp), %rdx
callq 0xb435
testl %eax, %eax
je 0xb5b4
movq 0x1327f(%rip), %rdi     # 0x1e800
movq 0x13280(%rip), %rsi     # 0x1e808
shlq $0x4, %r14
movq 0x13135(%rip), %rdx     # 0x1e6c8
addq %r14, %rdx
xorl %ebx, %ebx
pushq $0x1
popq %rcx
xorl %r8d, %r8d
callq 0x62a0
movq 0x1311e(%rip), %rax     # 0x1e6c8
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rax,%r14)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
	                                &prop) != Success)
		return;
	XSetWMIconName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname);
	XFree(prop.value);
}

// Assembly:
testq %rdi, %rdi
jne 0xbc14
movq 0x12d3c(%rip), %rdi     # 0x1e950
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x12bd8(%rip), %rdi     # 0x1e800
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x10(%rsp), %r8
callq 0x6540
testl %eax, %eax
jne 0xbc7c
movq 0x12bbd(%rip), %rdi     # 0x1e800
movq 0x12bc6(%rip), %rsi     # 0x1e810
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x63b0
movq 0x12ba2(%rip), %rdi     # 0x1e800
movq 0x12bab(%rip), %rsi     # 0x1e810
movq 0x12bd4(%rip), %rcx     # 0x1e840
movq %rbx, %rdx
callq 0x6560
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
	                                &prop) != Success)
		return;
	XSetWMName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
	XFree(prop.value);
}

// Assembly:
testq %rdi, %rdi
jne 0xbc8e
movq 0x12cc2(%rip), %rdi     # 0x1e950
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x12b5e(%rip), %rdi     # 0x1e800
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x10(%rsp), %r8
callq 0x6540
testl %eax, %eax
jne 0xbcf6
movq 0x12b43(%rip), %rdi     # 0x1e800
movq 0x12b4c(%rip), %rsi     # 0x1e810
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x64d0
movq 0x12b28(%rip), %rdi     # 0x1e800
movq 0x12b31(%rip), %rsi     # 0x1e810
movq 0x12b52(%rip), %rcx     # 0x1e838
movq %rbx, %rdx
callq 0x6560
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq