LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xc4f1(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x816d(%rip), %rsi      # 0x14c76
movb $0x0, %al
callq 0x69d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x1587d(%rip), %rax     # 0x223a0
jae 0xcc05
movq -0x8(%rbp), %rcx
leaq 0x1566c(%rip), %rax     # 0x221a0
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
callq 0x6460
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0xcb71
movl -0xc(%rbp), %edi
movq 0xc48c(%rip), %rax      # 0x18ff0
movq (%rax), %rsi
callq 0x6620
jmp 0xcbf2
cmpl $0xa, -0xc(%rbp)
jne 0xcb91
movq 0xc472(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x80af(%rip), %rsi      # 0x14c37
movb $0x0, %al
callq 0x69d0
jmp 0xcbf0
cmpl $0xd, -0xc(%rbp)
jne 0xcbb1
movq 0xc452(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x8094(%rip), %rsi      # 0x14c3c
movb $0x0, %al
callq 0x69d0
jmp 0xcbee
cmpl $0x1b, -0xc(%rbp)
jne 0xcbd1
movq 0xc432(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
leaq 0x8079(%rip), %rsi      # 0x14c41
movb $0x0, %al
callq 0x69d0
jmp 0xcbec
movq 0xc418(%rip), %rax      # 0x18ff0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x8061(%rip), %rsi      # 0x14c46
movb $0x0, %al
callq 0x69d0
jmp 0xcbee
jmp 0xcbf0
jmp 0xcbf2
jmp 0xcbf4
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xcb18
movq 0xc3e4(%rip), %rax      # 0x18ff0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x6620
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tinsertblank
void
tinsertblank(int n)
{
	int dst, src, size;
	Glyph *line;

	LIMIT(n, 0, term.col - term.c.x);

	dst = term.c.x + n;
	src = term.c.x;
	size = term.col - dst;
	line = term.line[term.c.y];

	memmove(&line[dst], &line[src], size * sizeof(Glyph));
	tclearregion(src, term.c.y, dst - 1, term.c.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xcc38
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcc68
movl -0x4(%rbp), %eax
movl 0xf5a3(%rip), %ecx      # 0x1c1e4
subl 0x13451(%rip), %ecx     # 0x20098
cmpl %ecx, %eax
jle 0xcc5c
movl 0xf593(%rip), %eax      # 0x1c1e4
subl 0x13441(%rip), %eax     # 0x20098
movl %eax, -0x20(%rbp)
jmp 0xcc62
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x13424(%rip), %eax     # 0x20098
addl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x13418(%rip), %eax     # 0x20098
movl %eax, -0xc(%rbp)
movl 0xf55b(%rip), %eax      # 0x1c1e4
subl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0xf552(%rip), %rax      # 0x1c1e8
movslq 0x133ff(%rip), %rcx     # 0x2009c
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x6630
movl -0xc(%rbp), %edi
movl 0x133c3(%rip), %esi     # 0x2009c
movl -0x8(%rbp), %edx
subl $0x1, %edx
movl 0x133b7(%rip), %ecx     # 0x2009c
callq 0x98b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xcd6e
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd9e
movl -0x8(%rbp), %eax
movl 0x13339(%rip), %ecx     # 0x200b0
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xcd92
movl 0x13329(%rip), %eax     # 0x200b0
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcd98
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xce0d
movl 0x132c8(%rip), %eax     # 0x20078
addl $0x1, %eax
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movl %edx, 0x132b7(%rip)     # 0x20078
movslq 0x132b0(%rip), %rcx     # 0x20078
leaq 0xf411(%rip), %rax      # 0x1c1e0
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xf409(%rip), %rax      # 0x1c1e8
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq 0x1328a(%rip), %rcx     # 0x20078
leaq 0xf3eb(%rip), %rax      # 0x1c1e0
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xf3e3(%rip), %rax      # 0x1c1e8
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %esi
movl 0xf3ce(%rip), %edx      # 0x1c1e4
subl $0x1, %edx
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
subl $0x1, %ecx
xorl %edi, %edi
callq 0x98b0
movl -0x4(%rbp), %edi
addl -0x8(%rbp), %edi
movl 0x1327b(%rip), %esi     # 0x200b0
callq 0x71a0
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x13267(%rip), %ecx     # 0x200b0
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jg 0xcea9
movq 0xf391(%rip), %rax      # 0x1c1e8
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xf37e(%rip), %rax      # 0x1c1e8
movl -0x10(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xf36a(%rip), %rax      # 0x1c1e8
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xf357(%rip), %rax      # 0x1c1e8
movl -0x10(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xce40
movl -0x4(%rbp), %edi
xorl %esi, %esi
subl -0x8(%rbp), %esi
callq 0x90c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xcede
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcf0e
movl -0x8(%rbp), %eax
movl 0x131c9(%rip), %ecx     # 0x200b0
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xcf02
movl 0x131b9(%rip), %eax     # 0x200b0
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcf08
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xcf88
movl 0x13158(%rip), %eax     # 0x20078
subl $0x1, %eax
addl $0x7d0, %eax            # imm = 0x7D0
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movl %edx, 0x13142(%rip)     # 0x20078
movslq 0x1313b(%rip), %rcx     # 0x20078
leaq 0xf29c(%rip), %rax      # 0x1c1e0
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xf294(%rip), %rax      # 0x1c1e8
movslq 0x13155(%rip), %rcx     # 0x200b0
movq (%rax,%rcx,8), %rdx
movslq 0x13112(%rip), %rcx     # 0x20078
leaq 0xf273(%rip), %rax      # 0x1c1e0
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xf26b(%rip), %rax      # 0x1c1e8
movslq 0x1312c(%rip), %rcx     # 0x200b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %edi
movl 0x1311f(%rip), %esi     # 0x200b0
subl -0x8(%rbp), %esi
callq 0x71a0
movl 0x13111(%rip), %esi     # 0x200b0
subl -0x8(%rbp), %esi
addl $0x1, %esi
movl 0xf239(%rip), %edx      # 0x1c1e4
subl $0x1, %edx
movl 0x130fc(%rip), %ecx     # 0x200b0
xorl %edi, %edi
callq 0x98b0
movl 0x130ef(%rip), %eax     # 0x200b0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0xd02a
movq 0xf210(%rip), %rax      # 0x1c1e8
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xf1fd(%rip), %rax      # 0x1c1e8
movl -0x10(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xf1e9(%rip), %rax      # 0x1c1e8
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xf1d6(%rip), %rax      # 0x1c1e8
movl -0x10(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcfc4
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x90c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tdeletechar
void
tdeletechar(int n)
{
	int dst, src, size;
	Glyph *line;

	LIMIT(n, 0, term.col - term.c.x);

	dst = term.c.x;
	src = term.c.x + n;
	size = term.col - src;
	line = term.line[term.c.y];

	memmove(&line[dst], &line[src], size * sizeof(Glyph));
	tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xd5f8
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd628
movl -0x4(%rbp), %eax
movl 0xebe3(%rip), %ecx      # 0x1c1e4
subl 0x12a91(%rip), %ecx     # 0x20098
cmpl %ecx, %eax
jle 0xd61c
movl 0xebd3(%rip), %eax      # 0x1c1e4
subl 0x12a81(%rip), %eax     # 0x20098
movl %eax, -0x20(%rbp)
jmp 0xd622
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x12a64(%rip), %eax     # 0x20098
movl %eax, -0x8(%rbp)
movl 0x12a5b(%rip), %eax     # 0x20098
addl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0xeb9b(%rip), %eax      # 0x1c1e4
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0xeb92(%rip), %rax      # 0x1c1e8
movslq 0x12a3f(%rip), %rcx     # 0x2009c
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x6630
movl 0xeb4e(%rip), %edi      # 0x1c1e4
subl -0x4(%rbp), %edi
movl 0x129fd(%rip), %esi     # 0x2009c
movl 0xeb3f(%rip), %edx      # 0x1c1e4
subl $0x1, %edx
movl 0x129ee(%rip), %ecx     # 0x2009c
callq 0x98b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x14aa5(%rip), %rdi     # 0x22738
callq 0x63d0
movq $0x0, 0x14a95(%rip) # 0x22738
cmpq $0x0, 0x14a85(%rip)     # 0x22730
je 0xdcf4
movq 0x14a7c(%rip), %rdi     # 0x22730
callq 0x6d20
movq %rax, 0x14a78(%rip)     # 0x22738
movq 0x148c9(%rip), %rdi     # 0x22590
leaq 0x755b(%rip), %rsi      # 0x15229
xorl %edx, %edx
callq 0x6870
movq %rax, -0x10(%rbp)
movq 0x148b0(%rip), %rdi     # 0x22590
movq -0x10(%rbp), %rsi
movq 0x148b5(%rip), %rdx     # 0x225a0
xorl %eax, %eax
movl %eax, %ecx
callq 0x6740
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdd39
jmp 0xdd8b
movq 0x149f0(%rip), %rdi     # 0x22730
callq 0x63d0
movq -0x8(%rbp), %rax
movq %rax, 0x149e0(%rip)     # 0x22730
movq 0x14839(%rip), %rdi     # 0x22590
movq 0x14842(%rip), %rdx     # 0x225a0
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x6740
movq 0x1481d(%rip), %rdi     # 0x22590
movl $0x1, %esi
callq 0x6a40
cmpq 0x1481c(%rip), %rax     # 0x225a0
je 0xdd8b
callq 0x6fb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x146a1(%rip)     # 0x22450
je 0xde0b
movq 0x146a0(%rip), %rax     # 0x22458
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x14691(%rip), %rcx     # 0x22458
movq 0x14692(%rip), %rdx     # 0x22460
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xde09
movq 0x147af(%rip), %rdi     # 0x22590
movq 0x147b0(%rip), %rsi     # 0x22598
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x62a0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xddbc
jmp 0xde2d
movq $0x104, 0x1464a(%rip) # imm = 0x104
movq 0x14643(%rip), %rdi     # 0x22460
shlq $0x4, %rdi
callq 0x6bd0
movq %rax, 0x1462b(%rip)     # 0x22458
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x14621(%rip), %rax     # 0x22460
jae 0xdeb8
movl -0x4(%rbp), %edi
movq 0x1460d(%rip), %rdx     # 0x22458
movslq -0x4(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xded0
cmpl $0x0, %eax
jne 0xdea8
movslq -0x4(%rbp), %rcx
leaq 0xb951(%rip), %rax      # 0x197c0
cmpq $0x0, (%rax,%rcx,8)
je 0xde95
movslq -0x4(%rbp), %rcx
leaq 0xb93f(%rip), %rax      # 0x197c0
movq (%rax,%rcx,8), %rsi
leaq 0x7231(%rip), %rdi      # 0x150bd
movb $0x0, %al
callq 0x6c20
jmp 0xdea6
movl -0x4(%rbp), %esi
leaq 0x723d(%rip), %rdi      # 0x150dc
movb $0x0, %al
callq 0x6c20
jmp 0xdea8
jmp 0xdeaa
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xde34
movl $0x1, 0x1458e(%rip)     # 0x22450
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdfef
movl $0x10, %eax
cmpl -0x8(%rbp), %eax
jg 0xdfda
cmpl $0xff, -0x8(%rbp)
jg 0xdfda
cmpl $0xe8, -0x8(%rbp)
jge 0xdf77
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x24, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x11180
movw %ax, -0x30(%rbp)
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x11180
movw %ax, -0x2e(%rbp)
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x1, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x11180
movw %ax, -0x2c(%rbp)
jmp 0xdf9a
movl -0x8(%rbp), %eax
subl $0xe8, %eax
imull $0xa0a, %eax, %eax      # imm = 0xA0A
addl $0x808, %eax            # imm = 0x808
movw %ax, -0x30(%rbp)
movw -0x30(%rbp), %ax
movw %ax, -0x2c(%rbp)
movw %ax, -0x2e(%rbp)
movw -0x30(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movw -0x2e(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, 0xa(%rax)
movw -0x2c(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, 0xc(%rax)
movq 0x145cb(%rip), %rdi     # 0x22590
movq 0x145cc(%rip), %rsi     # 0x22598
movq -0x18(%rbp), %rdx
callq 0x6860
movl %eax, -0x4(%rbp)
jmp 0xe011
movslq -0x8(%rbp), %rcx
leaq 0xb7db(%rip), %rax      # 0x197c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xdfef
movq 0x1459a(%rip), %rdi     # 0x22590
movq 0x1459b(%rip), %rsi     # 0x22598
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
leaq -0x28(%rbp), %rcx
callq 0x6270
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xe047
movslq -0x8(%rbp), %rax
cmpq 0x1441b(%rip), %rax     # 0x22460
jbe 0xe050
movl $0x1, -0x4(%rbp)
jmp 0xe0ba
movq 0x14401(%rip), %rax     # 0x22458
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x8(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq 0x143e0(%rip), %rax     # 0x22458
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq 0x143bf(%rip), %rax     # 0x22458
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xc(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xe0e3
movslq -0x8(%rbp), %rax
cmpq 0x1437f(%rip), %rax     # 0x22460
jbe 0xe0ec
movl $0x1, -0x4(%rbp)
jmp 0xe161
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xded0
cmpl $0x0, %eax
jne 0xe10a
movl $0x1, -0x4(%rbp)
jmp 0xe161
movq 0x1447f(%rip), %rdi     # 0x22590
movq 0x14480(%rip), %rsi     # 0x22598
movq 0x14339(%rip), %rdx     # 0x22458
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x62a0
movq 0x14318(%rip), %rax     # 0x22458
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xea0d
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xea18
movq 0x13ccc(%rip), %rax     # 0x226e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x13b69(%rip), %rdi     # 0x22590
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x6540
cmpl $0x0, %eax
je 0xea45
jmp 0xea83
movq 0x13b44(%rip), %rdi     # 0x22590
movq 0x13b4d(%rip), %rsi     # 0x225a0
leaq -0x28(%rbp), %rdx
callq 0x63b0
movq 0x13b2d(%rip), %rdi     # 0x22590
movq 0x13b36(%rip), %rsi     # 0x225a0
movq 0x13b5f(%rip), %rcx     # 0x225d0
leaq -0x28(%rbp), %rdx
callq 0x6560
movq -0x28(%rbp), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeaad
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xeab8
movq 0x13c2c(%rip), %rax     # 0x226e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x13ac9(%rip), %rdi     # 0x22590
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x6540
cmpl $0x0, %eax
je 0xeae5
jmp 0xeb23
movq 0x13aa4(%rip), %rdi     # 0x22590
movq 0x13aad(%rip), %rsi     # 0x225a0
leaq -0x28(%rbp), %rdx
callq 0x64d0
movq 0x13a8d(%rip), %rdi     # 0x22590
movq 0x13a96(%rip), %rsi     # 0x225a0
movq 0x13ab7(%rip), %rcx     # 0x225c8
leaq -0x28(%rbp), %rdx
callq 0x6560
movq -0x28(%rbp), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xdrawline
void
xdrawline(Line line, int x1, int y1, int x2)
{
	int i, x, ox, numspecs;
	Glyph base, new;
	GlyphFontSpec *specs = xw.specbuf;

	numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);

	i = ox = 0;
	for (x = x1; x < x2 && i < numspecs; x++) {
		new = line[x];
		if (new.mode == ATTR_WDUMMY)
			continue;
		if (selected(x, y1))
			new.mode ^= ATTR_REVERSE;
		if (i > 0 && ATTRCMP(base, new)) {
			xdrawglyphfontspecs(specs, base, i, ox, y1);
			specs += i;
			numspecs -= i;
			i = 0;
		}
		if (i == 0) {
			ox = x;
			base = new;
		}
		i++;
	}
	if (i > 0)
		xdrawglyphfontspecs(specs, base, i, ox, y1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq 0x13a44(%rip), %rax     # 0x225b0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
subl -0xc(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
callq 0xece0
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x51(%rbp)
jge 0xebc5
movl -0x18(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xebd1
jmp 0xecb2
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x44(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x3c(%rbp)
movzwl -0x40(%rbp), %eax
cmpl $0x400, %eax            # imm = 0x400
jne 0xebff
jmp 0xeca4
movl -0x1c(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x7380
cmpl $0x0, %eax
je 0xec1a
movzwl -0x40(%rbp), %eax
xorl $0x20, %eax
movw %ax, -0x40(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0xec7f
movzwl -0x30(%rbp), %eax
movzwl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0xec3c
movl -0x2c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jne 0xec3c
movl -0x28(%rbp), %eax
cmpl -0x38(%rbp), %eax
je 0xec7f
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x10(%rbp), %r9d
movq -0x34(%rbp), %rsi
movq -0x2c(%rbp), %rdx
callq 0xefe0
movl -0x18(%rbp), %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x18(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xec9b
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x44(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xebac
cmpl $0x0, -0x18(%rbp)
jle 0xecd4
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x10(%rbp), %r9d
movq -0x34(%rbp), %rsi
movq -0x2c(%rbp), %rdx
callq 0xefe0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xfinishdraw
void
xfinishdraw(void)
{
	XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w,
			win.h, 0, 0);
	XSetForeground(xw.dpy, dc.gc,
			dc.col[IS_SET(MODE_REVERSE)?
				defaultfg : defaultbg].pixel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x12f91(%rip), %rdi     # 0x22590
movq 0x12fa2(%rip), %rsi     # 0x225a8
movq 0x12f93(%rip), %rdx     # 0x225a0
movq 0x12f74(%rip), %rcx     # 0x22588
movl 0x130a5(%rip), %r10d    # 0x226c0
movl 0x130a3(%rip), %eax     # 0x226c4
xorl %r9d, %r9d
movl %r9d, %r8d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0x63f0
movq 0x12f45(%rip), %rax     # 0x22590
movq %rax, -0x18(%rbp)
movq 0x12f32(%rip), %rax     # 0x22588
movq %rax, -0x10(%rbp)
movq 0x12df7(%rip), %rax     # 0x22458
movq %rax, -0x8(%rbp)
movl 0x13069(%rip), %eax     # 0x226d4
andl $0x20, %eax
cmpl $0x0, %eax
je 0xf67e
movl 0xa133(%rip), %eax      # 0x197ac
movl %eax, -0x1c(%rbp)
jmp 0xf687
movl 0xa12c(%rip), %eax      # 0x197b0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
callq 0x6470
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
	if (xw.ime.xic == NULL)
		return;
	/* '-1' for underline. */
	XPoint spot = { borderpx + x * win.cw, (y + 1) * win.ch - 1 };
	XVaNestedList attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);

	xw.ime.spot.x = borderpx + x * win.cw;
	xw.ime.spot.y = (y + 1) * win.ch - 1;

	XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL);
	XFree(attr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpq $0x0, 0x12f22(%rip)     # 0x225e8
jne 0xf6cd
jmp 0xf76c
movl 0xa929(%rip), %eax      # 0x19ffc
movl -0x4(%rbp), %ecx
imull 0x12fef(%rip), %ecx     # 0x226cc
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
imull 0x12fd8(%rip), %eax     # 0x226c8
subl $0x1, %eax
movw %ax, -0xa(%rbp)
xorl %edi, %edi
leaq 0x5a38(%rip), %rsi      # 0x15138
leaq -0xc(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x67e0
movq %rax, -0x18(%rbp)
movl 0xa8e3(%rip), %eax      # 0x19ffc
movl -0x4(%rbp), %ecx
imull 0x12fa9(%rip), %ecx     # 0x226cc
addl %ecx, %eax
movw %ax, 0x12ec4(%rip)      # 0x225f0
movl -0x8(%rbp), %eax
addl $0x1, %eax
imull 0x12f8f(%rip), %eax     # 0x226c8
subl $0x1, %eax
movw %ax, 0x12eaf(%rip)      # 0x225f2
movq 0x12e9e(%rip), %rdi     # 0x225e8
movq 0x12ea7(%rip), %rdx     # 0x225f8
leaq 0x59ed(%rip), %rsi      # 0x15145
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x62d0
movq -0x18(%rbp), %rdi
callq 0x6090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xsetmode
void
xsetmode(int set, unsigned int flags)
{
	int mode = win.mode;
	MODBIT(win.mode, set, flags);
	if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
		redraw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x12ed0(%rip), %eax     # 0x226d4
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xf81e
movl -0x8(%rbp), %eax
orl 0x12ebe(%rip), %eax     # 0x226d4
movl %eax, 0x12eb8(%rip)     # 0x226d4
jmp 0xf830
movl -0x8(%rbp), %eax
xorl $-0x1, %eax
andl 0x12eaa(%rip), %eax     # 0x226d4
movl %eax, 0x12ea4(%rip)     # 0x226d4
movl 0x12e9e(%rip), %eax     # 0x226d4
andl $0x20, %eax
movl -0xc(%rbp), %ecx
andl $0x20, %ecx
cmpl %ecx, %eax
je 0xf848
callq 0x9ee0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xsetcursor
int
xsetcursor(int cursor)
{
	if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */
		return 1;
	win.cursor = cursor;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xf864
cmpl $0x7, -0x8(%rbp)
jle 0xf86d
movl $0x1, -0x4(%rbp)
jmp 0xf87d
movl -0x8(%rbp), %eax
movl %eax, 0x12e62(%rip)     # 0x226d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xbell
void
xbell(void)
{
	if (!(IS_SET(MODE_FOCUSED)))
		xseturgency(1);
	if (bellvolume)
		XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x12e3a(%rip), %eax     # 0x226d4
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xf8ac
movl $0x1, %edi
callq 0xf8e0
cmpl $0x0, 0x12b99(%rip)     # 0x2244c
je 0xf8d2
movq 0x12cd4(%rip), %rdi     # 0x22590
movq 0x12cdd(%rip), %rsi     # 0x225a0
movl 0x12b83(%rip), %edx     # 0x2244c
xorl %eax, %eax
movl %eax, %ecx
callq 0x6a00
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xseturgency
void
xseturgency(int add)
{
	XWMHints *h = XGetWMHints(xw.dpy, xw.win);

	MODBIT(h->flags, add, XUrgencyHint);
	XSetWMHints(xw.dpy, xw.win, h);
	XFree(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x12c9e(%rip), %rdi     # 0x22590
movq 0x12ca7(%rip), %rsi     # 0x225a0
callq 0x6610
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xf91b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
orq $0x100, %rcx            # imm = 0x100
movq %rcx, (%rax)
jmp 0xf92c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x101, %rcx           # imm = 0xFEFF
movq %rcx, (%rax)
movq 0x12c5d(%rip), %rdi     # 0x22590
movq 0x12c66(%rip), %rsi     # 0x225a0
movq -0x10(%rbp), %rdx
callq 0x6a70
movq -0x10(%rbp), %rdi
callq 0x6090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: resourceload
int
resourceload(XrmDatabase db, char *name, enum resource_type rtype, void *dst)
{
	char **sdst = dst;
	int *idst = dst;
	float *fdst = dst;

	char fullname[256];
	char fullclass[256];
	char *type;
	XrmValue ret;

	snprintf(fullname, sizeof(fullname), "%s.%s",
			opt_name ? opt_name : "st", name);
	snprintf(fullclass, sizeof(fullclass), "%s.%s",
			opt_class ? opt_class : "St", name);
	fullname[sizeof(fullname) - 1] = fullclass[sizeof(fullclass) - 1] = '\0';

	XrmGetResource(db, fullname, fullclass, &type, &ret);
	if (ret.addr == NULL || strncmp("String", type, 64))
		return 1;

	switch (rtype) {
	case STRING:
		*sdst = ret.addr;
		break;
	case INTEGER:
		*idst = strtoul(ret.addr, NULL, 10);
		break;
	case FLOAT:
		*fdst = strtof(ret.addr, NULL);
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x260(%rbp)
cmpq $0x0, 0x12d40(%rip)     # 0x226e8
je 0xf9ba
movq 0x12d37(%rip), %rax     # 0x226e8
movq %rax, -0x268(%rbp)
jmp 0xf9ca
leaq 0x579c(%rip), %rax      # 0x1515d
movq %rax, -0x268(%rbp)
jmp 0xf9ca
movq -0x260(%rbp), %rdi
movq -0x268(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x576f(%rip), %rdx      # 0x15157
movb $0x0, %al
callq 0x60c0
leaq -0x240(%rbp), %rax
movq %rax, -0x270(%rbp)
cmpq $0x0, 0x12ceb(%rip)     # 0x226f0
je 0xfa17
movq 0x12ce2(%rip), %rax     # 0x226f0
movq %rax, -0x278(%rbp)
jmp 0xfa27
leaq 0x5742(%rip), %rax      # 0x15160
movq %rax, -0x278(%rbp)
jmp 0xfa27
movq -0x270(%rbp), %rdi
movq -0x278(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x5712(%rip), %rdx      # 0x15157
movb $0x0, %al
callq 0x60c0
movb $0x0, -0x141(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0x240(%rbp), %rdx
leaq -0x248(%rbp), %rcx
leaq -0x258(%rbp), %r8
callq 0x6940
cmpq $0x0, -0x250(%rbp)
je 0xfaa3
movq -0x248(%rbp), %rsi
leaq 0x56cf(%rip), %rdi      # 0x15163
movl $0x40, %edx
callq 0x6220
cmpl $0x0, %eax
je 0xfaac
movl $0x1, -0x4(%rbp)
jmp 0xfb23
movl -0x1c(%rbp), %eax
movl %eax, -0x27c(%rbp)
testl %eax, %eax
je 0xfad5
jmp 0xfabb
movl -0x27c(%rbp), %eax
subl $0x1, %eax
je 0xfae5
jmp 0xfac8
movl -0x27c(%rbp), %eax
subl $0x2, %eax
je 0xfb04
jmp 0xfb1c
movq -0x250(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfb1c
movq -0x250(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x6a20
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0xfb1c
movq -0x250(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6580
movq -0x40(%rbp), %rax
movss %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xdrawglyphfontspec
void
xdrawglyphfontspec(XColor *fg, const GlyphFontSpec *specs, int len)
{
	cairo_font_face_t *prev = NULL;
	int i;

	cairo_set_font_size(xw.draw, defaultfontsize);
	cairo_set_source_rgb(xw.draw, CONVCOL(fg->red), CONVCOL(fg->green), CONVCOL(fg->blue));
	for (i = 0; i < len; i++) {
		if (prev != specs[i].font->cairo) {
			prev = specs[i].font->cairo;
			cairo_set_font_face(xw.draw, prev);
		}
		cairo_show_glyphs(xw.draw, (cairo_glyph_t *)&specs[i].glyph, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x113be(%rip), %rdi     # 0x22600
movsd 0x11516(%rip), %xmm0    # 0x22760
callq 0x64e0
movq 0x113aa(%rip), %rdi     # 0x22600
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x3cce(%rip), %xmm1     # 0x14f38
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
cvtsi2sd %eax, %xmm1
movsd 0x3cb6(%rip), %xmm2     # 0x14f38
divsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %eax
cvtsi2sd %eax, %xmm2
movsd 0x3c9e(%rip), %xmm3     # 0x14f38
divsd %xmm3, %xmm2
callq 0x63e0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11327
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
je 0x112f8
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x11311(%rip), %rdi     # 0x22600
movq -0x20(%rbp), %rsi
callq 0x6450
movq 0x11301(%rip), %rdi     # 0x22600
movq -0x10(%rbp), %rsi
movslq -0x24(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x60a0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x112aa
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: configinit
void
configinit(Display *dpy)
{
	char *resm;
	ResourcePref *p;

	XrmInitialize();
	resm = XResourceManagerString(dpy);
	if (!resm)
		return;

	db = XrmGetStringDatabase(resm);
	for (p = resources; p < resources + LEN(resources); p++)
		resourceload(db, p->name, p->type, p->dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6670
movq -0x8(%rbp), %rdi
callq 0x61a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11367
jmp 0x113c5
movq -0x10(%rbp), %rdi
callq 0x67a0
movq %rax, 0x11401(%rip)     # 0x22778
leaq 0x8c92(%rip), %rax      # 0x1a010
movq %rax, -0x18(%rbp)
leaq 0x8c87(%rip), %rax      # 0x1a010
addq $0x2b8, %rax            # imm = 0x2B8
cmpq %rax, -0x18(%rbp)
jae 0x113c5
movq 0x113dc(%rip), %rdi     # 0x22778
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0xf960
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x11382
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: ximpickupstyle
XIMStyle
ximpickupstyle(XIM xim)
{
	/* default is root style */
	XIMStyle style = (XIMPreeditNothing | XIMStatusNothing);
	XIMStyles *styles;
	int i, j;
	int len = sizeof(ximstyles) / sizeof(XIMStyle);

	XGetIMValues(xim, XNQueryInputStyle, &styles, NULL);
	for (i = 0; i < len; i++)
		for (j = 0; j < styles->count_styles; j++)
			if (ximstyles[i] == styles->supported_styles[j])
				goto LOOP_END;
LOOP_END:
	if (i < styles->count_styles)
		style = ximstyles[i];
	XFree(styles);
	return style;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x408, -0x10(%rbp)     # imm = 0x408
movl $0x2, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3482(%rip), %rsi      # 0x154c8
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x61d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x120b6
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x120a9
movslq -0x1c(%rbp), %rcx
leaq 0x82cc(%rip), %rax      # 0x1a350
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x1209c
jmp 0x120b8
jmp 0x1209e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1206b
jmp 0x120ab
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1205c
jmp 0x120b8
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x120d9
movslq -0x1c(%rbp), %rcx
leaq 0x827f(%rip), %rax      # 0x1a350
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6090
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: ximcreatepreeditattrs
XIMPreeditAttrs *
ximcreatepreeditattrs(Display *dpy, XIMStyle ximstyle)
{
	char pat[32];
	char **missingcharlist;
	int nummissingcharlist;
	char *defstring;
	XPoint spot = { .x = 0, .y = 0 };
	XIMPreeditAttrs *attrs;

	if (XIMPreeditPosition & ximstyle) {
		attrs = calloc(1, sizeof(XIMPreeditAttrs));
		// '-1' for underline.
		sprintf(pat, "-*-*-*-R-*-*-%d-*-*-*-*-*-*,*", dc.font.height-1);
		attrs->fontset = XCreateFontSet(dpy, pat, &missingcharlist,
		                                &nummissingcharlist, &defstring);
		if (missingcharlist)
			XFreeStringList(missingcharlist);
		if (!attrs->fontset)
			die("XCreateFontset failed.");
		attrs->list = XVaCreateNestedList(0, XNFontSet, attrs->fontset,
		                                  XNSpotLocation, &spot,
		                                  XNForeground, dc.col[defaultfg].pixel,
		                                  XNBackground, dc.col[defaultbg].pixel,
		                                  NULL);
		return attrs;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x5c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x60b0
movq -0x20(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x1222d
movl $0x1, %edi
movl $0x10, %esi
callq 0x6850
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movl 0x10325(%rip), %edx     # 0x22468
subl $0x1, %edx
leaq 0x338b(%rip), %rsi      # 0x154d8
movb $0x0, %al
callq 0x64c0
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
leaq -0x58(%rbp), %r8
callq 0x64a0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x48(%rbp)
je 0x12188
movq -0x48(%rbp), %rdi
callq 0x6820
movq -0x68(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x121a1
leaq 0x335c(%rip), %rdi      # 0x154f6
movb $0x0, %al
callq 0x6c20
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdx
movq 0x102a8(%rip), %rax     # 0x22458
movl 0x75f6(%rip), %ecx      # 0x197ac
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %r11
movq 0x10291(%rip), %rax     # 0x22458
movl 0x75e3(%rip), %ecx      # 0x197b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
xorl %edi, %edi
leaq 0x332d(%rip), %rsi      # 0x1550d
leaq 0x2f51(%rip), %rcx      # 0x15138
leaq -0x5c(%rbp), %r8
leaq 0x290a(%rip), %r9       # 0x14afc
leaq 0x290e(%rip), %r10      # 0x14b07
xorl %ebx, %ebx
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, %al
callq 0x67e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12235
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xgeommasktogravity
int
xgeommasktogravity(int mask)
{
	switch (mask & (XNegative|YNegative)) {
	case 0:
		return NorthWestGravity;
	case XNegative:
		return NorthEastGravity;
	case YNegative:
		return SouthWestGravity;
	}

	return SouthEastGravity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x30, %eax
movl %eax, -0xc(%rbp)
je 0x122b8
jmp 0x122a4
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0x122c1
jmp 0x122ae
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x122ca
jmp 0x122d3
movl $0x1, -0x4(%rbp)
jmp 0x122da
movl $0x3, -0x4(%rbp)
jmp 0x122da
movl $0x7, -0x4(%rbp)
jmp 0x122da
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
	int col, row;

	if (width != 0)
		win.w = width;
	if (height != 0)
		win.h = height;

	col = (win.w - 2 * borderpx) / win.cw;
	row = (win.h - 2 * borderpx) / win.ch;
	col = MAX(1, col);
	row = MAX(1, row);

	tresize(col, row);
	xresize(col, row);
	ttyresize(win.tw, win.th);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x122fd
movl -0x4(%rbp), %eax
movl %eax, 0x103c3(%rip)     # 0x226c0
cmpl $0x0, -0x8(%rbp)
je 0x1230c
movl -0x8(%rbp), %eax
movl %eax, 0x103b8(%rip)     # 0x226c4
movl 0x103ae(%rip), %eax     # 0x226c0
movl 0x7ce4(%rip), %ecx      # 0x19ffc
shll %ecx
subl %ecx, %eax
cltd
idivl 0x103a9(%rip)           # 0x226cc
movl %eax, -0xc(%rbp)
movl 0x10398(%rip), %eax     # 0x226c4
movl 0x7cca(%rip), %ecx      # 0x19ffc
shll %ecx
subl %ecx, %eax
cltd
idivl 0x1038b(%rip)           # 0x226c8
movl %eax, -0x10(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0x12352
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1235c
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1235c
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0x10(%rbp), %eax
jge 0x12374
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1237e
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1237e
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x8a30
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x123c0
movl 0x10318(%rip), %edi     # 0x226b8
movl 0x10316(%rip), %esi     # 0x226bc
callq 0x8800
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: xresize
void
xresize(int col, int row)
{
	cairo_surface_t *surface;
	win.tw = col * win.cw;
	win.th = row * win.ch;

	XFreePixmap(xw.dpy, xw.buf);
	cairo_destroy(xw.draw);
	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
			DefaultDepth(xw.dpy, xw.scr));

	surface = cairo_xlib_surface_create(xw.dpy, xw.buf, xw.vis, win.w, win.h);
	xw.draw = cairo_create(surface);
	cairo_surface_destroy(surface);
	xclear(0, 0, win.w, win.h);

	/* resize to new width */
	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull 0x102f4(%rip), %eax     # 0x226cc
movl %eax, 0x102da(%rip)     # 0x226b8
movl -0x8(%rbp), %eax
imull 0x102e0(%rip), %eax     # 0x226c8
movl %eax, 0x102ce(%rip)     # 0x226bc
movq 0x1019b(%rip), %rdi     # 0x22590
movq 0x101ac(%rip), %rsi     # 0x225a8
callq 0x6910
movq 0x101f8(%rip), %rdi     # 0x22600
callq 0x6160
movq 0x1017c(%rip), %rdi     # 0x22590
movq 0x10185(%rip), %rsi     # 0x225a0
movl 0x1029f(%rip), %edx     # 0x226c0
movl 0x1029d(%rip), %ecx     # 0x226c4
movq 0x10162(%rip), %rax     # 0x22590
movq 0xe8(%rax), %rax
movslq 0x10244(%rip), %r8      # 0x22680
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x69b0
movq %rax, 0x10155(%rip)     # 0x225a8
movq 0x10136(%rip), %rdi     # 0x22590
movq 0x10147(%rip), %rsi     # 0x225a8
movq 0x101a0(%rip), %rdx     # 0x22608
movl 0x10252(%rip), %ecx     # 0x226c0
movl 0x1024f(%rip), %r8d     # 0x226c4
callq 0x6520
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6500
movq %rax, 0x10172(%rip)     # 0x22600
movq -0x10(%rbp), %rdi
callq 0x68a0
movl 0x10223(%rip), %edx     # 0x226c0
movl 0x10221(%rip), %ecx     # 0x226c4
xorl %esi, %esi
movl %esi, %edi
callq 0x111b0
movq 0x100fd(%rip), %rdi     # 0x225b0
movslq -0x4(%rbp), %rsi
shlq $0x5, %rsi
callq 0x6cd0
movq %rax, 0x100e9(%rip)     # 0x225b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)