LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xaf50
leaq 0xe527(%rip), %rax      # 0x19440
movslq 0x12400(%rip), %rcx     # 0x1d320
cmpb $0x0, 0x3edc(%rcx,%rax)
jne 0xaf50
movl %edi, %eax
leaq -0x7(%rax), %rcx
cmpq $0x17, %rcx
jb 0xaf50
leaq 0xb113(%rip), %rcx      # 0x16050
movq (%rcx,%rax,8), %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x9d4c
movq 0xe4f1(%rip), %rcx      # 0x19448
movslq %ebp, %rax
movq (%rcx,%rax,8), %rdx
movslq %ebx, %rcx
shlq $0x4, %rcx
movzwl 0x4(%rdx,%rcx), %esi
btl $0x9, %esi
jb 0xaf7e
btl $0xa, %esi
jae 0xaf9f
decl %ebx
movw $0xfdff, %si            # imm = 0xFDFF
jmp 0xaf8c
incl %ebx
movw $0xfbff, %si            # imm = 0xFBFF
cmpl 0xe4ba(%rip), %ebx      # 0x19444
jge 0xaf9f
movslq %ebx, %rdi
shlq $0x4, %rdi
movl $0x20, (%rdx,%rdi)
andw %si, 0x4(%rdx,%rdi)
movq 0x1233a(%rip), %rsi     # 0x1d2e0
movl $0x1, (%rsi,%rax,4)
movups 0x12334(%rip), %xmm0    # 0x1d2e8
movups %xmm0, (%rdx,%rcx)
movl 0x4(%rsp), %edx
movq 0xe485(%rip), %rsi      # 0x19448
movq (%rsi,%rax,8), %rax
movl %edx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12321(%rip), %eax     # 0x1d2f8
testl %edi, %edi
jle 0xb013
movl 0xe463(%rip), %edx      # 0x19444
cmpl %edx, %eax
jae 0xb050
movq 0x1233c(%rip), %rsi     # 0x1d328
subl $0x1, %edi
jb 0xb050
movl %eax, %r8d
incq %r8
movl %eax, %ecx
cmpq %rdx, %r8
jae 0xb049
incl %ecx
cmpl $0x0, (%rsi,%r8,4)
leaq 0x1(%r8), %r8
je 0xaff9
movl %ecx, %eax
cmpl %ecx, %edx
ja 0xafec
jmp 0xb052
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb050
movq 0x122ff(%rip), %rdx     # 0x1d328
incl %edi
decl %eax
movl %eax, %ecx
subl $0x1, %ecx
jb 0xb066
movl %eax, %eax
cmpl $0x0, (%rdx,%rax,4)
movl %ecx, %eax
je 0xb02f
leal 0x1(%rcx), %eax
testl %edi, %edi
jne 0xb029
incl %ecx
jmp 0xb052
incl %eax
cmpl %eax, %edx
cmoval %edx, %eax
movl %eax, %ecx
movl 0xe3ec(%rip), %eax      # 0x19444
decl %eax
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl %eax, 0x12293(%rip)     # 0x1d2f8
retq
xorl %ecx, %ecx
jmp 0xb052
// File: /workspace/github_c_makefile_star2_O3/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
movl %edi, %ebx
cmpl $0x9d, %edi
jg 0xb608
cmpl $0x90, %ebx
je 0xb61c
cmpl $0x9d, %ebx
jne 0xb622
movb $0x5d, %bl
jmp 0xb622
cmpl $0x9e, %ebx
je 0xb620
cmpl $0x9f, %ebx
jne 0xb622
movb $0x5f, %bl
jmp 0xb622
movb $0x50, %bl
jmp 0xb622
movb $0x5e, %bl
movq 0x13d37(%rip), %rdi     # 0x1f360
movl $0x200, %esi            # imm = 0x200
callq 0x7140
movq $0x0, 0x13d1a(%rip) # 0x1f358
movq %rax, 0x13d1b(%rip)     # 0x1f360
movq $0x200, 0x13d18(%rip) # imm = 0x200
leaq 0x13d19(%rip), %rdi     # 0x1f370
movl $0x90, %edx
xorl %esi, %esi
callq 0x60b0
movb %bl, 0x13cef(%rip)      # 0x1f358
orb $0x4, 0x11ca8(%rip)     # 0x1d318
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/st.c
// Function: base64dec
char *
base64dec(const char *src)
{
	size_t in_len = strlen(src);
	char *result, *dst;
	static const char base64_digits[256] = {
		[43] = 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
		0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
		13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0,
		0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
	};

	if (in_len % 4)
		in_len += 4 - (in_len % 4);
	result = dst = xmalloc(in_len / 4 * 3 + 1);
	while (*src) {
		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
		int d = base64_digits[(unsigned char) base64dec_getc(&src)];

		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
		if (a == -1 || b == -1)
			break;

		*dst++ = (a << 2) | ((b & 0x30) >> 4);
		if (c == -1)
			break;
		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
		if (d == -1)
			break;
		*dst++ = ((c & 0x03) << 6) | d;
	}
	*dst = '\0';
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rdi, 0x10(%rsp)
callq 0x6410
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incq %rdi
callq 0x707c
cmpb $0x0, (%r14)
movq %rax, %r15
je 0xb766
movq %rax, 0x8(%rsp)
movq %rax, %r15
addq $0x2, %r15
leaq 0x10(%rsp), %r14
leaq 0x5e0a(%rip), %r12      # 0x114d0
movq %r14, %rdi
callq 0xb85d
movzbl %al, %eax
movb (%rax,%r12), %bl
movq %r14, %rdi
callq 0xb85d
movzbl %al, %eax
movb (%rax,%r12), %bpl
movq %r14, %rdi
callq 0xb85d
movzbl %al, %eax
movb (%rax,%r12), %r13b
movq %r14, %rdi
callq 0xb85d
cmpb $-0x1, %bl
je 0xb758
cmpb $-0x1, %bpl
je 0xb758
movzbl %al, %eax
movb (%rax,%r12), %al
shlb $0x2, %bl
movl %ebp, %ecx
shrb $0x4, %cl
andb $0x3, %cl
orb %bl, %cl
movb %cl, -0x2(%r15)
cmpb $-0x1, %r13b
je 0xb75e
shlb $0x4, %bpl
movl %r13d, %ecx
shrb $0x2, %cl
andb $0xf, %cl
orb %bpl, %cl
movb %cl, -0x1(%r15)
cmpb $-0x1, %al
je 0xb761
shlb $0x6, %r13b
orb %r13b, %al
movb %al, (%r15)
movq 0x10(%rsp), %rax
addq $0x3, %r15
cmpb $0x0, (%rax)
jne 0xb6c6
addq $-0x2, %r15
jmp 0xb761
decq %r15
movq 0x8(%rsp), %rax
movb $0x0, (%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc4bf
testl %eax, %eax
jne 0xb81b
testl %ebx, %ebx
leaq 0x6f1c(%rip), %rax      # 0x126ce
leaq 0x61a7(%rip), %rcx      # 0x11960
cmoveq %rax, %rcx
movzbl 0xf(%rsp), %r9d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
subq $0x8, %rsp
leaq 0x615f(%rip), %rdx      # 0x11939
leaq 0x18(%rsp), %rdi
movl $0x20, %esi
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 0xb84c
movl %eax, %esi
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x8127
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
movq 0xc7cc(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x6107(%rip), %rax      # 0x11935
leaq 0x60fb(%rip), %rdx      # 0x11930
cmoveq %rax, %rdx
leaq 0x60cb(%rip), %rsi      # 0x1190b
movl %r14d, %ecx
xorl %eax, %eax
callq 0x69c0
jmp 0xb812
xorl %esi, %esi
testl %ebx, %ebx
sete %sil
movl %eax, %edi
callq 0x6e39
jmp 0xb812
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movslq 0x11a3f(%rip), %rbx     # 0x1d2f8
movl 0xdb85(%rip), %eax      # 0x19444
movl %eax, %ecx
subl %ebx, %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
xorl %r14d, %r14d
testl %edi, %edi
cmovnsl %ecx, %r14d
leal (%rbx,%r14), %ecx
subl %ecx, %eax
movq 0xdb6a(%rip), %rdx      # 0x19448
movslq 0x11a17(%rip), %rsi     # 0x1d2fc
movq (%rdx,%rsi,8), %rdx
movslq %ecx, %rdi
shlq $0x4, %rdi
addq %rdx, %rdi
movq %rbx, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
movslq %eax, %rdx
shlq $0x4, %rdx
callq 0x6630
movl 0x119ed(%rip), %ecx     # 0x1d2fc
leal (%rbx,%r14), %edx
decl %edx
movl %ebx, %edi
movl %ecx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x91c0
// File: /workspace/github_c_makefile_star2_O3/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 0xb948
movl 0x119d7(%rip), %r14d    # 0x1d310
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xb94b
xorl %r14d, %r14d
movslq %ebx, %r15
testl %edx, %edx
je 0xb9af
leaq 0xdae7(%rip), %rax      # 0x19440
movl 0x11979(%rip), %ecx     # 0x1d2d8
movl %ecx, %edx
incl %edx
movslq %edx, %rdx
imulq $0x10624dd3, %rdx, %rdx # imm = 0x10624DD3
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x27, %rdx
addl %esi, %edx
imull $0x7d0, %edx, %edx      # imm = 0x7D0
negl %edx
addl %edx, %ecx
incl %ecx
movl %ecx, 0x1194c(%rip)     # 0x1d2d8
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rdx
movq 0xdaad(%rip), %rsi      # 0x19448
movq (%rsi,%r15,8), %rsi
movq %rsi, 0x18(%rax,%rcx,8)
movq 0xda9d(%rip), %rax      # 0x19448
movq %rdx, (%rax,%r15,8)
movl 0xda8f(%rip), %edx      # 0x19444
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x91c0
movl 0x11940(%rip), %esi     # 0x1d310
movl %ebp, %edi
callq 0x73fb
movl 0x11933(%rip), %eax     # 0x1d310
movl %eax, %ecx
subl %r14d, %ecx
cmpl %ebx, %ecx
jl 0xba18
movslq %r14d, %rcx
addq %r15, %rcx
notl %eax
addl %ebp, %eax
movq 0xda51(%rip), %rdx      # 0x19448
movq (%rdx,%r15,8), %rsi
movq (%rdx,%rcx,8), %rdi
movq %rdi, (%rdx,%r15,8)
movq 0xda3e(%rip), %rdx      # 0x19448
movq %rsi, (%rdx,%rcx,8)
incq %r15
incq %rcx
incl %eax
jne 0xb9f0
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8c64
// File: /workspace/github_c_makefile_star2_O3/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 0x118d2(%rip), %rsi     # 0x1d310
testl %eax, %eax
js 0xba54
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0xba57
xorl %r14d, %r14d
testl %edx, %edx
je 0xbac0
leaq 0xd9de(%rip), %rax      # 0x19440
movl 0x11870(%rip), %ecx     # 0x1d2d8
movl %ecx, %edx
addl $0x7cf, %edx            # imm = 0x7CF
movslq %edx, %rdx
imulq $0x10624dd3, %rdx, %rdx # imm = 0x10624DD3
movq %rdx, %rdi
shrq $0x3f, %rdi
sarq $0x27, %rdx
addl %edi, %edx
imull $0x7d0, %edx, %edx      # imm = 0x7D0
negl %edx
addl %edx, %ecx
addl $0x7cf, %ecx            # imm = 0x7CF
movl %ecx, 0x1183b(%rip)     # 0x1d2d8
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rdx
movq 0xd99c(%rip), %rdi      # 0x19448
movq (%rdi,%rsi,8), %rdi
movq %rdi, 0x18(%rax,%rcx,8)
movq 0xd98c(%rip), %rax      # 0x19448
movq %rdx, (%rax,%rsi,8)
subl %r14d, %esi
movl %ebx, %edi
callq 0x73fb
movl 0x11840(%rip), %ecx     # 0x1d310
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0xd967(%rip), %edx      # 0x19444
decl %edx
xorl %edi, %edi
callq 0x91c0
movslq 0x11823(%rip), %rax     # 0x1d310
leal (%r14,%rbx), %edx
cmpl %edx, %eax
jl 0xbb36
movslq %r14d, %rcx
movslq %edx, %rdx
incq %rax
shlq $0x3, %rcx
negq %rcx
movq 0xd93c(%rip), %rsi      # 0x19448
leaq (%rsi,%rax,8), %rdi
movq -0x8(%rsi,%rax,8), %r8
movq -0x8(%rcx,%rdi), %rdi
movq %rdi, -0x8(%rsi,%rax,8)
movq 0xd922(%rip), %rsi      # 0x19448
addq %rcx, %rsi
movq %r8, -0x8(%rsi,%rax,8)
decq %rax
cmpq %rdx, %rax
jg 0xbb05
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8c64
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %eax
movslq 0x113f6(%rip), %rdi     # 0x1d2f8
movl 0xd53c(%rip), %ecx      # 0x19444
movl %ecx, %edx
subl %edi, %edx
cmpl %eax, %edx
cmovgel %eax, %edx
xorl %ebx, %ebx
testl %eax, %eax
cmovnsl %edx, %ebx
leal (%rdi,%rbx), %eax
subl %eax, %ecx
movq 0xd524(%rip), %rdx      # 0x19448
movslq 0x113d1(%rip), %rsi     # 0x1d2fc
movq (%rdx,%rsi,8), %rdx
shlq $0x4, %rdi
addq %rdx, %rdi
movslq %eax, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
movslq %ecx, %rdx
shlq $0x4, %rdx
callq 0x6630
movl 0xd4f2(%rip), %edx      # 0x19444
movl %edx, %edi
subl %ebx, %edi
movl 0x113a0(%rip), %ecx     # 0x1d2fc
decl %edx
movl %ecx, %esi
popq %rbx
jmp 0x91c0
// File: /workspace/github_c_makefile_star2_O3/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 0x132e6(%rip), %r8      # 0x1f400
movl 0x210(%r8,%rdx,4), %eax
cmpl $0x5, %eax
je 0xc180
leaq (%r8,%rdx,4), %rcx
addq $0x20c, %rcx            # imm = 0x20C
cmpl $0x2, %eax
jne 0xc1c7
leal 0x4(%rdx), %r9d
cmpl %esi, %r9d
jge 0xc1ad
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %ecx
movl 0x21c(%r8,%rdx,4), %r8d
movl %r9d, (%rdi)
cmpl $0xff, %eax
ja 0xc1d1
cmpl $0xff, %ecx
ja 0xc1d1
cmpl $0x100, %r8d            # imm = 0x100
jae 0xc1d1
shll $0x10, %eax
shll $0x8, %ecx
orl %eax, %ecx
leal (%r8,%rcx), %eax
addl $0x1000000, %eax        # imm = 0x1000000
jmp 0xc1f0
leal 0x2(%rdx), %eax
cmpl %esi, %eax
jge 0xc1ad
movl %eax, (%rdi)
movl 0x214(%r8,%rdx,4), %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xc1f0
movq 0xbe51(%rip), %rcx      # 0x17ff0
movq (%rcx), %rdi
leaq 0x5915(%rip), %rsi      # 0x11abe
movl %eax, %edx
jmp 0xc1be
movq 0xbe3c(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x58ad(%rip), %rsi      # 0x11a6b
xorl %eax, %eax
callq 0x69c0
jmp 0xc1eb
movq %rcx, %rdi
callq 0x6ea2
jmp 0xc1eb
movq 0xbe18(%rip), %rdx      # 0x17ff0
movq (%rdx), %rdi
leaq 0x58ba(%rip), %rsi      # 0x11a9c
movl %eax, %edx
xorl %eax, %eax
callq 0x69c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1379a(%rip), %rdi     # 0x1f998
callq 0x63d0
movq $0x0, 0x1378a(%rip) # 0x1f998
movq 0x1377b(%rip), %rdi     # 0x1f990
testq %rdi, %rdi
je 0xc254
callq 0x716a
movq %rax, 0x13772(%rip)     # 0x1f998
movq 0x135c3(%rip), %rdi     # 0x1f7f0
leaq 0x5d8d(%rip), %rsi      # 0x11fc1
xorl %edx, %edx
callq 0x6850
movq 0x135ae(%rip), %rdi     # 0x1f7f0
movq 0x135b7(%rip), %rdx     # 0x1f800
movq %rax, %rsi
xorl %ecx, %ecx
popq %rax
jmp 0x6740
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc2bd
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x13720(%rip), %rdi     # 0x1f990
callq 0x63d0
movq %r14, 0x13714(%rip)     # 0x1f990
movq 0x1356d(%rip), %rdi     # 0x1f7f0
movq 0x13576(%rip), %rdx     # 0x1f800
movl $0x1, %esi
movq %rbx, %rcx
callq 0x6740
movq 0x13552(%rip), %rdi     # 0x1f7f0
movl $0x1, %esi
callq 0x6a30
cmpq 0x13551(%rip), %rax     # 0x1f800
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
jne 0x72d0
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x133e2(%rip)     # 0x1f6b0
jne 0xc321
movq 0x133e9(%rip), %rax     # 0x1f6c0
testq %rax, %rax
jle 0xc344
movq 0x133d5(%rip), %rbx     # 0x1f6b8
movq 0x13506(%rip), %rdi     # 0x1f7f0
movq 0x13507(%rip), %rsi     # 0x1f7f8
movq %rbx, %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x62a0
addq $0x10, %rbx
movq 0x133b4(%rip), %rax     # 0x1f6c0
movq %rax, %rcx
shlq $0x4, %rcx
addq 0x1339e(%rip), %rcx     # 0x1f6b8
cmpq %rcx, %rbx
jb 0xc2e3
jmp 0xc344
movq $0x104, 0x13394(%rip) # imm = 0x104
movl $0x1040, %edi           # imm = 0x1040
callq 0x707c
movq %rax, 0x1337b(%rip)     # 0x1f6b8
movq 0x1337c(%rip), %rax     # 0x1f6c0
testq %rax, %rax
je 0xc3b2
leaq 0xc270(%rip), %r12      # 0x185c0
leaq 0x5b1d(%rip), %rbx      # 0x11e74
leaq 0x5af7(%rip), %r14      # 0x11e55
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x1334d(%rip), %rdx     # 0x1f6b8
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xc3c3
testl %eax, %eax
jne 0xc39e
movq (%r12), %rsi
testq %rsi, %rsi
je 0xc391
movq %r14, %rdi
xorl %eax, %eax
callq 0x70a6
jmp 0xc39e
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x70a6
incq %r15
addq $0x8, %r12
addq $0x10, %r13
cmpq %r15, 0x13310(%rip)     # 0x1f6c0
ja 0xc364
movb $0x1, 0x132f7(%rip)     # 0x1f6b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc469
leal -0x10(%rdi), %r9d
cmpl $0xef, %r9d
ja 0xc45b
cmpl $0xe7, %edi
ja 0xc48a
movzbl %r9b, %ecx
imull $0x39, %ecx, %eax
shrl $0xb, %eax
imull $0x2828, %eax, %eax     # imm = 0x2828
movl $0x3737, %esi           # imm = 0x3737
addl %esi, %eax
xorl %edx, %edx
cmpl $0x24, %r9d
cmovbl %edx, %eax
imull $0xab, %ecx, %r9d
shrl $0xa, %r9d
imull $0x2b, %r9d, %edi
shrl $0x7, %edi
andl $-0x2, %edi
leal (%rdi,%rdi,2), %edi
movl %r9d, %r10d
subb %dil, %r10b
movzbl %r10b, %r10d
imull $0x2828, %r10d, %edi    # imm = 0x2828
addl %esi, %edi
testb %r10b, %r10b
cmovel %edx, %edi
addl %r9d, %r9d
leal (%r9,%r9,2), %r9d
subb %r9b, %cl
movzbl %cl, %r9d
imull $0x2828, %r9d, %ecx     # imm = 0x2828
addl %esi, %ecx
testb %r9b, %r9b
cmovel %edx, %ecx
jmp 0xc49a
movslq %edi, %rax
leaq 0xc15b(%rip), %rcx      # 0x185c0
movq (%rcx,%rax,8), %rdx
subq $0x18, %rsp
movq 0x1337c(%rip), %rdi     # 0x1f7f0
movq 0x1337d(%rip), %rsi     # 0x1f7f8
leaq 0x8(%rsp), %rcx
callq 0x6270
addq $0x18, %rsp
retq
imull $0xa0a, %edi, %ecx      # imm = 0xA0A
addl $0xffffeef8, %ecx       # imm = 0xFFFFEEF8
movl %ecx, %edi
movl %ecx, %eax
movw %ax, 0x8(%r8)
movw %di, 0xa(%r8)
movw %cx, 0xc(%r8)
movq 0x13340(%rip), %rdi     # 0x1f7f0
movq 0x13341(%rip), %rsi     # 0x1f7f8
movq %r8, %rdx
jmp 0x6840
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x1, %eax
testl %edi, %edi
js 0xc500
movl %edi, %edi
cmpq %rdi, 0x131ef(%rip)     # 0x1f6c0
jb 0xc500
movq 0x131de(%rip), %rax     # 0x1f6b8
shlq $0x4, %rdi
movb 0x9(%rax,%rdi), %al
movb %al, (%rsi)
movq 0x131cd(%rip), %rax     # 0x1f6b8
movb 0xb(%rax,%rdi), %al
movb %al, (%rdx)
movq 0x131c0(%rip), %rax     # 0x1f6b8
movb 0xd(%rax,%rdi), %al
movb %al, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebx
testl %edi, %edi
js 0xc567
movl %edi, %r14d
cmpq %r14, 0x131a5(%rip)     # 0x1f6c0
jb 0xc567
leaq 0x8(%rsp), %rdx
callq 0xc3c3
testl %eax, %eax
je 0xc567
movq 0x132be(%rip), %rdi     # 0x1f7f0
movq 0x132bf(%rip), %rsi     # 0x1f7f8
shlq $0x4, %r14
movq 0x13174(%rip), %rdx     # 0x1f6b8
addq %r14, %rdx
xorl %ebx, %ebx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x62a0
movq 0x1315b(%rip), %rax     # 0x1f6b8
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_O3/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 0xcbe9
movq 0x12d57(%rip), %rdi     # 0x1f940
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x12bf3(%rip), %rdi     # 0x1f7f0
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6540
testl %eax, %eax
jne 0xcc55
movq 0x12bd4(%rip), %rdi     # 0x1f7f0
movq 0x12bdd(%rip), %rsi     # 0x1f800
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x63b0
movq 0x12bb9(%rip), %rdi     # 0x1f7f0
movq 0x12bc2(%rip), %rsi     # 0x1f800
movq 0x12beb(%rip), %rcx     # 0x1f830
movq %rbx, %rdx
callq 0x6560
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcc67
movq 0x12cd9(%rip), %rdi     # 0x1f940
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x12b75(%rip), %rdi     # 0x1f7f0
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6540
testl %eax, %eax
jne 0xccd3
movq 0x12b56(%rip), %rdi     # 0x1f7f0
movq 0x12b5f(%rip), %rsi     # 0x1f800
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x64d0
movq 0x12b3b(%rip), %rdi     # 0x1f7f0
movq 0x12b44(%rip), %rsi     # 0x1f800
movq 0x12b65(%rip), %rcx     # 0x1f828
movq %rbx, %rdx
callq 0x6560
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebx
movl %edx, %r8d
movl %esi, %ebp
movq %rdi, %r14
movq 0x12b0e(%rip), %rdi     # 0x1f810
movslq %esi, %r15
movq %r15, %r12
shlq $0x4, %r12
leaq (%r14,%r12), %rsi
movl %ecx, %edx
subl %r15d, %edx
setg %r13b
movq %rdi, 0x18(%rsp)
movl %r15d, %ecx
movl %r8d, 0x10(%rsp)
callq 0xcebb
testl %eax, %eax
setg %cl
andb %r13b, %cl
cmpb $0x1, %cl
jne 0xceac
movslq %ebx, %rdx
leaq (%r12,%r14), %rbx
addq $0xc, %rbx
incq %r15
xorl %r13d, %r13d
movl $0x0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movzwl -0x8(%rbx), %r14d
cmpl $0x400, %r14d           # imm = 0x400
je 0xce61
movl %eax, 0x14(%rsp)
movl -0xc(%rbx), %eax
movq %rax, 0x48(%rsp)
movl -0x4(%rbx), %eax
movq %rax, 0x40(%rsp)
movzwl -0x6(%rbx), %eax
movq %rax, 0x50(%rsp)
movl (%rbx), %eax
movq %rax, 0x38(%rsp)
movl %ebp, %edi
movl 0x10(%rsp), %esi
callq 0x763e
movl %r14d, %r12d
xorl $0x20, %r12d
testl %eax, %eax
cmovel %r14d, %r12d
testl %r13d, %r13d
jle 0xcddf
movq 0x28(%rsp), %rax
shrq $0x20, %rax
cmpw %ax, %r12w
movq 0x30(%rsp), %rdx
jne 0xcdec
cmpl %edx, 0x40(%rsp)
jne 0xcdec
movq %rdx, %rax
shrq $0x20, %rax
cmpl %eax, 0x38(%rsp)
jne 0xcdec
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rdx
jmp 0xce5e
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rdx
jne 0xce5e
jmp 0xce26
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq 0x28(%rsp), %rsi
movl %r13d, %ecx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
callq 0xd0b0
movl %r13d, %eax
shlq $0x5, %rax
addq %rax, %r14
movq %r14, 0x18(%rsp)
movl 0x14(%rsp), %eax
subl %r13d, %eax
movq 0x20(%rsp), %rdx
movzwl %r12w, %ecx
shlq $0x20, %rcx
addq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rsi
shlq $0x30, %rsi
orq %rcx, %rsi
movq 0x38(%rsp), %rcx
shlq $0x20, %rcx
addq 0x40(%rsp), %rcx
xorl %r13d, %r13d
movq %rcx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %ebp, 0xc(%rsp)
incl %r13d
cmpq %rdx, %r15
jge 0xce78
incl %ebp
addq $0x10, %rbx
incq %r15
cmpl %eax, %r13d
jl 0xcd5a
testl %r13d, %r13d
jle 0xceac
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl %r13d, %ecx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd0b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x120e4(%rip), %rdi     # 0x1f7f0
movq 0x120f5(%rip), %rsi     # 0x1f808
movq 0x120e6(%rip), %rdx     # 0x1f800
movq 0x120c7(%rip), %rcx     # 0x1f7e8
movl 0x121f9(%rip), %eax     # 0x1f920
movl 0x121f6(%rip), %r10d    # 0x1f924
xorl %r11d, %r11d
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r11
pushq %r11
pushq %r10
pushq %rax
callq 0x63f0
addq $0x20, %rsp
movq 0x120a2(%rip), %rdi     # 0x1f7f0
movq 0x12093(%rip), %rsi     # 0x1f7e8
movq 0x11f5c(%rip), %rax     # 0x1f6b8
testb $0x20, 0x121d1(%rip)    # 0x1f934
leaq 0xae42(%rip), %rcx      # 0x185ac
leaq 0xae3f(%rip), %rdx      # 0x185b0
cmovneq %rcx, %rdx
movl (%rdx), %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
popq %rax
jmp 0x6470
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0x120bb(%rip)     # 0x1f848
je 0xd82e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl 0x12187(%rip), %eax     # 0x1f92c
imull %edi, %eax
addl 0xb64e(%rip), %eax      # 0x18dfc
leaq 0xc(%rsp), %rdx
movw %ax, (%rdx)
incl %ebx
movl 0x1216a(%rip), %eax     # 0x1f928
imull %ebx, %eax
decl %eax
movw %ax, 0x2(%rdx)
leaq 0x4702(%rip), %rsi      # 0x11ed0
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x67d0
imull 0x1214c(%rip), %ebp     # 0x1f92c
addl 0xb616(%rip), %ebp      # 0x18dfc
movq %rax, %r14
movw %bp, 0x12060(%rip)      # 0x1f850
imull 0x12131(%rip), %ebx     # 0x1f928
decl %ebx
movw %bx, 0x12052(%rip)      # 0x1f852
movq 0x12041(%rip), %rdi     # 0x1f848
movq 0x1204a(%rip), %rdx     # 0x1f858
leaq 0x46c8(%rip), %rsi      # 0x11edd
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x62d0
movq %r14, %rdi
callq 0x6090
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testb $0x2, 0x12087(%rip)     # 0x1f934
jne 0xd8be
pushq %rax
movl $0x1, %edi
callq 0xd8de
addq $0x8, %rsp
movl 0x11de8(%rip), %edx     # 0x1f6ac
testl %edx, %edx
je 0xd8dd
movq 0x11f21(%rip), %rdi     # 0x1f7f0
movq 0x11f2a(%rip), %rsi     # 0x1f800
xorl %ecx, %ecx
jmp 0x69f0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testl %edi, %edi
setne %r14b
movq 0x11efe(%rip), %rdi     # 0x1f7f0
movq 0x11f07(%rip), %rsi     # 0x1f800
callq 0x6610
movq %rax, %rbx
movq $-0x101, %rax           # imm = 0xFEFF
andq (%rbx), %rax
shll $0x8, %r14d
orq %rax, %r14
movq %r14, (%rbx)
movq 0x11ed4(%rip), %rdi     # 0x1f7f0
movq 0x11edd(%rip), %rsi     # 0x1f800
movq %rbx, %rdx
callq 0x6a60
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6090
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rcx, 0x8(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x11fe7(%rip), %rax     # 0x1f948
testq %rax, %rax
leaq 0x458a(%rip), %rcx      # 0x11ef5
cmovneq %rax, %rcx
leaq 0x4579(%rip), %r13      # 0x11eef
xorl %ebp, %ebp
leaq 0x130(%rsp), %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60c0
movq 0x11fb4(%rip), %rax     # 0x1f950
testq %rax, %rax
leaq 0x4552(%rip), %rcx      # 0x11ef8
cmovneq %rax, %rcx
leaq 0x30(%rsp), %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60c0
movb %bpl, 0xff(%rbx)
movb %bpl, 0xff(%r12)
leaq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %r8
callq 0x6920
movq 0x8(%r15), %r15
movl $0x1, %r14d
testq %r15, %r15
je 0xda17
movq 0x18(%rsp), %rsi
leaq 0x44f2(%rip), %rdi      # 0x11efb
movl $0x40, %edx
callq 0x6220
testl %eax, %eax
je 0xda2c
movl %r14d, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rsp), %eax
xorl %r14d, %r14d
cmpl $0x2, %eax
je 0xda63
cmpl $0x1, %eax
je 0xda4b
testl %eax, %eax
jne 0xda17
movq 0x8(%rsp), %rax
movq %r15, (%rax)
jmp 0xda17
movq %r15, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6a10
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
jmp 0xda17
movq %r15, %rdi
xorl %esi, %esi
callq 0x6580
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xda17
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: xhints
void
xhints(void)
{
	XClassHint class = {opt_name ? opt_name : "st",
	                    opt_class ? opt_class : "St"};
	XWMHints wm = {.flags = InputHint, .input = 1};
	XSizeHints *sizeh;

	sizeh = XAllocSizeHints();

	sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;
	sizeh->height = win.h;
	sizeh->width = win.w;
	sizeh->height_inc = win.ch;
	sizeh->width_inc = win.cw;
	sizeh->base_height = 2 * borderpx;
	sizeh->base_width = 2 * borderpx;
	sizeh->min_height = win.ch + 2 * borderpx;
	sizeh->min_width = win.cw + 2 * borderpx;
	if (xw.isfixed) {
		sizeh->flags |= PMaxSize;
		sizeh->min_width = sizeh->max_width = win.w;
		sizeh->min_height = sizeh->max_height = win.h;
	}
	if (xw.gm & (XValue|YValue)) {
		sizeh->flags |= USPosition | PWinGravity;
		sizeh->x = xw.l;
		sizeh->y = xw.t;
		sizeh->win_gravity = xgeommasktogravity(xw.gm);
	}

	XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm,
			&class);
	XFree(sizeh);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x109cd(%rip), %rax     # 0x1f948
testq %rax, %rax
leaq 0x2f70(%rip), %rcx      # 0x11ef5
cmovneq %rax, %rcx
movq 0x109c0(%rip), %rax     # 0x1f950
testq %rax, %rax
leaq 0x2f5e(%rip), %rdx      # 0x11ef8
cmovneq %rax, %rdx
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x68e0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0x10944(%rip), %eax     # 0x1f924
movl %eax, 0x14(%rbx)
movl 0x10937(%rip), %ecx     # 0x1f920
movl %ecx, 0x10(%rbx)
movl 0x10936(%rip), %edx     # 0x1f928
movl %edx, 0x2c(%rbx)
movl 0x10931(%rip), %esi     # 0x1f92c
movl %esi, 0x28(%rbx)
movl 0x9df8(%rip), %edi      # 0x18dfc
leal (%rdi,%rdi), %r8d
movl %r8d, 0x44(%rbx)
movl %r8d, 0x40(%rbx)
leal (%rdx,%rdi,2), %edx
movl %edx, 0x1c(%rbx)
leal (%rsi,%rdi,2), %edx
movl %edx, 0x18(%rbx)
cmpl $0x0, 0x108c1(%rip)     # 0x1f8e4
je 0xf03f
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl $0x379, %ecx            # imm = 0x379
jmp 0xf044
movl $0x359, %ecx            # imm = 0x359
movl 0x108a6(%rip), %eax     # 0x1f8f0
testb $0x3, %al
je 0xf06f
movq %rcx, (%rbx)
movq 0x10890(%rip), %rcx     # 0x1f8e8
movq %rcx, 0x8(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x2c97(%rip), %rcx      # 0x11d00
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0x1077a(%rip), %rdi     # 0x1f7f0
movq 0x10783(%rip), %rsi     # 0x1f800
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x6390
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x6090
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edi, %edi
je 0xf3ee
movl %edi, 0x10532(%rip)     # 0x1f920
testl %esi, %esi
je 0xf3fa
movl %esi, 0x1052c(%rip)     # 0x1f924
jmp 0xf400
movl 0x10524(%rip), %esi     # 0x1f924
pushq %rbp
pushq %r14
pushq %rbx
movl 0x10516(%rip), %eax     # 0x1f920
movl 0x99ec(%rip), %ecx      # 0x18dfc
addl %ecx, %ecx
subl %ecx, %eax
cltd
idivl 0x10511(%rip)           # 0x1f92c
movl %eax, %ebx
subl %ecx, %esi
movl %esi, %eax
cltd
idivl 0x10500(%rip)           # 0x1f928
cmpl $0x2, %ebx
movl $0x1, %ebp
cmovll %ebp, %ebx
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0x86b7
movl 0x104e4(%rip), %eax     # 0x1f92c
imull %ebx, %eax
imull 0x104d6(%rip), %ebp     # 0x1f928
movl %eax, 0x104c0(%rip)     # 0x1f918
movl %ebp, 0x104be(%rip)     # 0x1f91c
movq 0x1038b(%rip), %rdi     # 0x1f7f0
movq 0x1039c(%rip), %rsi     # 0x1f808
callq 0x68f0
movq 0x103e8(%rip), %rdi     # 0x1f860
callq 0x6160
movq 0x1036c(%rip), %rdi     # 0x1f7f0
movq 0x10375(%rip), %rsi     # 0x1f800
movl 0x1048f(%rip), %edx     # 0x1f920
movl 0x1048d(%rip), %ecx     # 0x1f924
movq 0xe8(%rdi), %rax
movslq 0x1043b(%rip), %r8      # 0x1f8e0
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x69a0
movq %rax, 0x1034e(%rip)     # 0x1f808
movq 0x1032f(%rip), %rdi     # 0x1f7f0
movq 0x103a0(%rip), %rdx     # 0x1f868
movl 0x10452(%rip), %ecx     # 0x1f920
movl 0x1044f(%rip), %r8d     # 0x1f924
movq %rax, %rsi
callq 0x6520
movq %rax, %r14
movq %rax, %rdi
callq 0x6500
movq %rax, 0x10371(%rip)     # 0x1f860
movq %r14, %rdi
callq 0x6880
movl 0x10423(%rip), %ecx     # 0x1f920
movl 0x10420(%rip), %r8d     # 0x1f924
testb $0x20, 0x10429(%rip)    # 0x1f934
leaq 0x909a(%rip), %rax      # 0x185ac
leaq 0x9097(%rip), %rdx      # 0x185b0
cmovneq %rax, %rdx
movq 0x10194(%rip), %rax     # 0x1f6b8
movl (%rdx), %edx
shlq $0x4, %rdx
movq (%rax,%rdx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcb84
movq 0x102d2(%rip), %rdi     # 0x1f810
shlq $0x5, %rbx
movq %rbx, %rsi
callq 0x7140
movq %rax, 0x102bf(%rip)     # 0x1f810
movl 0x103c1(%rip), %edi     # 0x1f918
movl 0x103bf(%rip), %esi     # 0x1f91c
popq %rbx
popq %r14
popq %rbp
jmp 0x8529
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: bpress
void
bpress(XEvent *e)
{
	int btn = e->xbutton.button;
	struct timespec now;
	int snap;

	if (1 <= btn && btn <= 11)
		buttons |= 1 << (btn-1);

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 0))
		return;

	if (btn == Button1) {
		/*
		 * If the user clicks below predefined timeouts specific
		 * snapping behaviour is exposed.
		 */
		clock_gettime(CLOCK_MONOTONIC, &now);
		if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
			snap = SNAP_LINE;
		} else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
			snap = SNAP_WORD;
		} else {
			snap = 0;
		}
		xsel.tclick2 = xsel.tclick1;
		xsel.tclick1 = now;

		selstart(evcol(e), evrow(e), snap);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf76c
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0x1027c(%rip)     # 0x1f9e8
movzwl 0x101c1(%rip), %eax     # 0x1f934
testl $0xc018, %eax           # imm = 0xC018
setne %al
movl 0x50(%rbx), %edi
testb $0x1, %dil
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf79b
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x1003d
movl %r14d, %esi
xorl %edx, %edx
callq 0x10239
cmpl $0x1, %r14d
jne 0xf8c3
testl %eax, %eax
jne 0xf8c3
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6140
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rdx, %rcx
subq 0x101d6(%rip), %rcx     # 0x1f9b0
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
movq %rax, %rcx
subq 0x101c8(%rip), %rcx     # 0x1f9b8
cvtsi2sd %rcx, %xmm1
divsd 0x248b(%rip), %xmm1     # 0x11c88
addsd %xmm0, %xmm1
movl $0x2, %ecx
movsd 0x24a2(%rip), %xmm0     # 0x11cb0
ucomisd %xmm1, %xmm0
jae 0xf856
subq 0x10185(%rip), %rdx     # 0x1f9a0
imulq $0x3e8, %rdx, %rcx      # imm = 0x3E8
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subq 0x10177(%rip), %rax     # 0x1f9a8
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd 0x2447(%rip), %xmm1     # 0x11c88
addsd %xmm0, %xmm1
movsd 0x246b(%rip), %xmm0     # 0x11cb8
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
setae %cl
movups 0x10143(%rip), %xmm0    # 0x1f9a0
movups %xmm0, 0x1014c(%rip)    # 0x1f9b0
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x10130(%rip)    # 0x1f9a0
movl 0x40(%rbx), %edx
movl 0x9582(%rip), %r8d      # 0x18dfc
xorl %esi, %esi
subl %r8d, %edx
movl $0x0, %eax
js 0xf893
movl 0x1008c(%rip), %eax     # 0x1f918
decl %eax
cmpl %eax, %edx
cmovll %edx, %eax
cltd
idivl 0x10092(%rip)           # 0x1f92c
movl %eax, %edi
movl 0x44(%rbx), %eax
subl %r8d, %eax
js 0xf8b1
movl 0x10072(%rip), %esi     # 0x1f91c
decl %esi
cmpl %esi, %eax
cmovll %eax, %esi
movl %esi, %eax
cltd
idivl 0x1006e(%rip)           # 0x1f928
movl %eax, %esi
movl %ecx, %edx
callq 0x7228
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
	int btn = e->xbutton.button;

	if (1 <= btn && btn <= 11)
		buttons &= ~(1 << (btn-1));

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 1))
		return;
	if (btn == Button1)
		mousesel(e, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf8ec
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
andl %eax, 0x100fc(%rip)     # 0x1f9e8
movzwl 0x10041(%rip), %eax     # 0x1f934
testl $0xc018, %eax           # imm = 0xC018
setne %al
movl 0x50(%rbx), %edi
testb $0x1, %dil
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf91b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1003d
movl %r14d, %esi
movl $0x1, %edx
callq 0x10239
cmpl $0x1, %r14d
jne 0xf946
testl %eax, %eax
jne 0xf946
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x102e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: focus
void
focus(XEvent *ev)
{
	XFocusChangeEvent *e = &ev->xfocus;

	if (e->mode == NotifyGrab)
		return;

	if (ev->type == FocusIn) {
		if (xw.ime.xic)
			XSetICFocus(xw.ime.xic);
		win.mode |= MODE_FOCUSED;
		xseturgency(0);
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[I", 3, 0);
	} else {
		if (xw.ime.xic)
			XUnsetICFocus(xw.ime.xic);
		win.mode &= ~MODE_FOCUSED;
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[O", 3, 0);
	}
}

// Assembly:
pushq %rax
cmpl $0x1, 0x28(%rdi)
jne 0xf977
popq %rax
retq
cmpl $0x9, (%rdi)
movq 0xfec7(%rip), %rdi      # 0x1f848
jne 0xf9ad
testq %rdi, %rdi
je 0xf98d
callq 0x6760
orb $0x2, 0xffa0(%rip)      # 0x1f934
xorl %edi, %edi
callq 0xd8de
testb $0x20, 0xff93(%rip)     # 0x1f935
je 0xf975
leaq 0x2d24(%rip), %rdi      # 0x126cf
jmp 0xf9d5
testq %rdi, %rdi
je 0xf9b7
callq 0x6490
movl 0xff77(%rip), %eax      # 0x1f934
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0xff6c(%rip)      # 0x1f934
btl $0xd, %eax
jae 0xf975
leaq 0x2cfe(%rip), %rdi      # 0x126d3
movl $0x3, %esi
xorl %edx, %edx
popq %rax
jmp 0x8127
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: propnotify
void
propnotify(XEvent *e)
{
	XPropertyEvent *xpev;
	Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

	xpev = &e->xproperty;
	if (xpev->state == PropertyNewValue &&
			(xpev->atom == XA_PRIMARY ||
			 xpev->atom == clipboard)) {
		selnotify(e);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xfdb9(%rip), %rdi      # 0x1f7f0
leaq 0x2583(%rip), %rsi      # 0x11fc1
xorl %edx, %edx
callq 0x6850
cmpl $0x0, 0x38(%rbx)
jne 0xfa5a
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0xfa5c
cmpq %rax, %rcx
je 0xfa5c
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xfbec
// File: /workspace/github_c_makefile_star2_O3/odknt[P]st/x.c
// Function: cmessage
void
cmessage(XEvent *e)
{
	/*
	 * See xembed specs
	 *  http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html
	 */
	if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
		if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {
			win.mode |= MODE_FOCUSED;
			xseturgency(0);
		} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
			win.mode &= ~MODE_FOCUSED;
		}
	} else if (e->xclient.data.l[0] == xw.wmdeletewin) {
		ttyhangup();
		exit(0);
	}
}

// Assembly:
movq 0x28(%rdi), %rax
cmpq 0xf9c6(%rip), %rax      # 0x1f818
jne 0xfe78
cmpl $0x20, 0x30(%rdi)
jne 0xfe78
movq 0x40(%rdi), %rax
cmpq $0x5, %rax
je 0xfe86
cmpq $0x4, %rax
jne 0xfe85
orb $0x2, 0xfac3(%rip)      # 0x1f934
xorl %edi, %edi
jmp 0xd8de
movq 0x38(%rdi), %rax
cmpq 0xf99d(%rip), %rax      # 0x1f820
je 0xfe8e
retq
andb $-0x3, 0xfaa7(%rip)     # 0x1f934
retq
pushq %rax
callq 0x8565
xorl %edi, %edi
callq 0x61b0