LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/evilwombat[P]gopro-fw-tools/h4-section-patch.c
// Function: read_file
unsigned char *read_file(const char *fname, unsigned int *out_size)
{
	unsigned char *buf;
	struct stat st;
	int size, ret;
	FILE *fd;

	ret = stat(fname, &st);
	if (ret) {
		printf("Error: Could not stat %s\n", fname);
		return NULL;
	}

	size = st.st_size;
	if (size <= 0) {
		printf("Bad file size of %s: %d\n", fname, size);
		return NULL;
	}

	fd = fopen(fname, "rb");
	if (!fd) {
		printf("Error opening file %s\n", fname);
		return NULL;
	}
		
	buf = malloc(size);
	if (!buf) {
		printf("Could not allocate %d bytes\n", size);
		fclose(fd);
		return NULL;
	}

	ret = fread(buf, size, 1, fd);
	
	if (ret != 1) {
		printf("Error reading file %s: %d\n", fname, ret);
		free(buf);
		fclose(fd);
		return NULL;
	}

	*out_size = size;
	fclose(fd);
	
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
callq 0x10b0
testl %eax, %eax
je 0x1259
leaq 0xddc(%rip), %rdi       # 0x2014
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1080
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rsp), %r12
testl %r12d, %r12d
jle 0x12af
leaq 0xddd(%rip), %rsi       # 0x2047
movq %r14, %rdi
callq 0x10e0
testq %rax, %rax
je 0x12ca
movq %rax, %r15
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %rbp, %rdi
callq 0x10d0
testq %rax, %rax
je 0x12d6
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %rbp, %rsi
movq %r15, %rcx
callq 0x1060
cmpl $0x1, %eax
jne 0x12f6
movl %r12d, (%r13)
jmp 0x12e9
leaq 0xd78(%rip), %rdi       # 0x202e
xorl %ebx, %ebx
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1080
jmp 0x1244
leaq 0xd79(%rip), %rdi       # 0x204a
jmp 0x1238
leaq 0xd84(%rip), %rdi       # 0x2061
xorl %ebx, %ebx
movl %r12d, %esi
xorl %eax, %eax
callq 0x1080
movq %r15, %rdi
callq 0x1070
jmp 0x1244
leaq 0xd81(%rip), %rdi       # 0x207e
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1070
xorl %ebx, %ebx
jmp 0x1244
// File: /workspace/github_c_makefile_star2_O2/evilwombat[P]gopro-fw-tools/h4-section-patch.c
// Function: print_sections
void print_sections(struct section_info *sections, int num_sections)
{
	int i;
	printf("Section\t\t  Offset\t  Length\t     CRC\n");
	printf("========================================================\n");
	for (i = 0; i < num_sections; i++) {
		printf("section_%d\t%8d\t%8d\t%08x (%s)\n",
		       i, sections[i].offset, sections[i].length, sections[i].header_crc,
			(sections[i].header_crc == sections[i].actual_crc) ? "OK" : "MISMATCH!"
		);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x125f(%rip), %rdi      # 0x2596
callq 0x1050
leaq 0x1277(%rip), %rdi      # 0x25ba
callq 0x1050
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
addq $0x1c, %r14
leaq 0xd5d(%rip), %r13       # 0x20b7
leaq 0xd59(%rip), %rbp       # 0x20ba
leaq 0xd31(%rip), %r15       # 0x2099
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x139d
movl -0x1c(%r14), %r8d
movq %r13, %r9
cmpl -0x18(%r14), %r8d
je 0x1380
movq %rbp, %r9
movl -0x4(%r14), %edx
movl (%r14), %ecx
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x1080
incq %r12
addq $0x20, %r14
jmp 0x136b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/evilwombat[P]gopro-fw-tools/h4-section-patch.c
// Function: get_global_crc
unsigned int get_global_crc(unsigned char *buf, int size)
{
	if (size < GLOBAL_HEADER_SIZE) {
		printf("Invalid firmware size: %d\n", size);
		return 0;
	}
	
	return crc32(buf + GLOBAL_HEADER_SIZE, size - GLOBAL_HEADER_SIZE);
}

// Assembly:
pushq %rbx
cmpl $0xdf, %esi
jg 0x13c7
leaq 0xd08(%rip), %rdi       # 0x20c4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1080
jmp 0x13dc
addq $0xe0, %rdi
addl $0xffffff20, %esi       # imm = 0xFFFFFF20
callq 0x1ba4
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ryuichiueda[P]glueutils/src/flip12.c
// Function: usage
void usage(void){
	fputs("flip12: flip stdout and stderr\n", stderr);
	fputs("usage: flip12 <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbx
movq 0x2e54(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xe56(%rip), %rdi       # 0x2004
callq 0x1060
movq (%rbx), %rsi
leaq 0xe67(%rip), %rdi       # 0x2024
callq 0x1060
movq (%rbx), %rsi
leaq 0xe78(%rip), %rdi       # 0x2044
callq 0x1060
movq (%rbx), %rsi
leaq 0xe8b(%rip), %rdi       # 0x2066
callq 0x1060
movq (%rbx), %rsi
leaq 0xe9d(%rip), %rdi       # 0x2087
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/ryuichiueda[P]glueutils/src/flip12.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 2){
		usage();
		exit(1);
	}

	trydup2(1, 3);
	trydup2(2, 1);
	trydup2(3, 2);

	return - execvp(argv[1], &argv[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x1278
movq %rsi, %rbx
pushq $0x1
popq %rbp
pushq $0x3
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x11f0
pushq $0x2
popq %r15
movl %r15d, %edi
movl %ebp, %esi
callq 0x11f0
movl %r14d, %edi
movl %r15d, %esi
callq 0x11f0
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x1070
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x119c
pushq $0x1
popq %rdi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: tinsync
int
tinsync(uint timeout)
{
    struct timespec now;
    if (su && !clock_gettime(CLOCK_MONOTONIC, &now)
           && TIMEDIFF(now, sutv) >= timeout)
        su = 0;
    return su;
}

// Assembly:
cmpb $0x1, 0x129fd(%rip)     # 0x194c0
jne 0x6b28
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
pushq $0x1
popq %rdi
movq %rsp, %rsi
callq 0x6130
testl %eax, %eax
jne 0x6b23
movq (%rsp), %rax
subq 0x129e2(%rip), %rax     # 0x194c8
movq 0x8(%rsp), %rcx
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cvtsi2sd %rax, %xmm0
subq 0x129d2(%rip), %rcx     # 0x194d0
cvtsi2sd %rcx, %xmm1
divsd 0xa4fd(%rip), %xmm1     # 0x11008
addsd %xmm0, %xmm1
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
ucomisd %xmm0, %xmm1
jb 0x6b23
movb $0x0, 0x1299d(%rip)     # 0x194c0
addq $0x10, %rsp
popq %rbx
movzbl 0x12991(%rip), %eax     # 0x194c0
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: utf8encode
size_t
utf8encode(Rune u, char *c)
{
    size_t len, i;

    len = utf8validate(&u, 0);
    if (len > UTF_SIZ)
        return 0;

    for (i = len - 1; i != 0; --i) {
        c[i] = utf8encodebyte(u, 0);
        u >>= 6;
    }
    c[0] = utf8encodebyte(u, len);

    return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %rax
movl %edi, (%rax)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x6cb9
cmpq $0x4, %rax
ja 0x6cae
movl 0x4(%rsp), %ecx
movq %rax, %rdx
decq %rdx
movq %rdx, %rsi
subq $0x1, %rsi
jb 0x6c90
movl %ecx, %edi
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, (%rbx,%rdx)
shrl $0x6, %ecx
movq %rsi, %rdx
jmp 0x6c74
leaq 0xa7d5(%rip), %rdx      # 0x1146c
leaq 0xa7d3(%rip), %rsi      # 0x11471
movzbl (%rax,%rsi), %esi
notl %esi
andl %esi, %ecx
orb (%rax,%rdx), %cl
movb %cl, (%rbx)
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: utf8validate
size_t
utf8validate(Rune *u, size_t i)
{
    if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
        *u = UTF_INVALID;
    for (i = 1; *u > utfmax[i]; ++i)
        ;

    return i;
}

// Assembly:
leaq 0xa7c0(%rip), %rax      # 0x11480
movl (%rdi), %ecx
cmpl %ecx, (%rax,%rsi,4)
jbe 0x6cd4
movl $0xfffd, (%rdi)         # imm = 0xFFFD
movl $0xfffd, %ecx           # imm = 0xFFFD
jmp 0x6cee
movl %ecx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x6cc7
leaq 0xa7b7(%rip), %rax      # 0x114a0
cmpl (%rax,%rsi,4), %ecx
ja 0x6cc7
xorl %eax, %eax
leaq 0xa7a9(%rip), %rdx      # 0x114a0
movq %rax, %rsi
incq %rax
cmpl 0x4(%rdx,%rsi,4), %ecx
ja 0x6cf7
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: selstart
void
selstart(int col, int row, int snap)
{
    selclear();
    sel.mode = SEL_EMPTY;
    sel.type = SEL_REGULAR;
    sel.alt = IS_SET(MODE_ALTSCREEN);
    sel.snap = snap;
    sel.oe.x = sel.ob.x = col;
    sel.oe.y = sel.ob.y = row;
    selnormalize();

    if (sel.snap != 0)
        sel.mode = SEL_READY;
    tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
callq 0x6d9a
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1279d(%rip)     # 0x194d8
movl 0x137bb(%rip), %eax     # 0x1a4fc
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0x127b7(%rip)     # 0x19504
movl %ebx, 0x1278d(%rip)     # 0x194e0
movl %r14d, 0x1279a(%rip)    # 0x194f4
movl %r14d, 0x1279b(%rip)    # 0x194fc
movl %ebp, 0x12791(%rip)     # 0x194f8
movl %ebp, 0x12793(%rip)     # 0x19500
callq 0x6dc3
cmpl $0x0, 0x12767(%rip)     # 0x194e0
je 0x6d85
movl $0x2, 0x12753(%rip)     # 0x194d8
movl 0x1275d(%rip), %edi     # 0x194e8
movl 0x1275f(%rip), %esi     # 0x194f0
popq %rbx
popq %r14
popq %rbp
jmp 0x6ebb
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: selclear
void
selclear(void)
{
    if (sel.ob.x == -1)
        return;
    sel.mode = SEL_IDLE;
    sel.ob.x = -1;
    tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
cmpl $-0x1, 0x12753(%rip)    # 0x194f4
je 0x6dc2
andl $0x0, 0x1272e(%rip)     # 0x194d8
orl $-0x1, 0x12743(%rip)    # 0x194f4
movl 0x12731(%rip), %edi     # 0x194e8
movl 0x12733(%rip), %esi     # 0x194f0
jmp 0x6ebb
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: selextend
void
selextend(int col, int row, int type, int done)
{
    int oldey, oldex, oldsby, oldsey, oldtype;

    if (sel.mode == SEL_IDLE)
        return;
    if (done && sel.mode == SEL_EMPTY) {
        selclear();
        return;
    }

    oldey = sel.oe.y;
    oldex = sel.oe.x;
    oldsby = sel.nb.y;
    oldsey = sel.ne.y;
    oldtype = sel.type;

    sel.oe.x = col;
    sel.oe.y = row;
    selnormalize();
    sel.type = type;

    if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
        tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));

    sel.mode = done ? SEL_IDLE : SEL_READY;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x125c3(%rip), %eax     # 0x194d8
testl %eax, %eax
je 0x6fd6
movl %ecx, %ebx
testl %ecx, %ecx
sete %cl
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x6f3f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6d9a
movl %edx, %ebp
movl 0x125a0(%rip), %r14d    # 0x194e8
movl 0x125a1(%rip), %r15d    # 0x194f0
movl 0x12586(%rip), %r12d    # 0x194dc
movsd 0x1259e(%rip), %xmm0    # 0x194fc
movaps %xmm0, (%rsp)
movl %edi, 0x12594(%rip)     # 0x194fc
movl %esi, 0x12592(%rip)     # 0x19500
callq 0x6dc3
movl %ebp, 0x12563(%rip)     # 0x194dc
movq 0x1257b(%rip), %xmm0    # 0x194fc
pcmpeqd (%rsp), %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x6fa2
cmpl %ebp, %r12d
jne 0x6fa2
cmpl $0x1, 0x12538(%rip)     # 0x194d8
jne 0x6fc7
movl 0x12540(%rip), %eax     # 0x194e8
cmpl %r14d, %eax
cmovll %eax, %r14d
movl 0x1253b(%rip), %eax     # 0x194f0
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl %r14d, %edi
movl %r15d, %esi
callq 0x6ebb
xorl %eax, %eax
testl %ebx, %ebx
sete %al
addl %eax, %eax
movl %eax, 0x12502(%rip)     # 0x194d8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: tlinelen
int
tlinelen(int y)
{
    int i = term.col;

    if (TLINE(y)[i - 1].mode & ATTR_WRAP)
        return i;

    while (i > 0 && TLINE(y)[i - 1].u == ' ')
        --i;

    return i;
}

// Assembly:
movl 0x1229f(%rip), %ecx     # 0x1950c
movslq %ecx, %r10
movl 0x1324e(%rip), %esi     # 0x1a4c4
movl %edi, %r9d
leaq 0x12288(%rip), %r8      # 0x19508
subl %esi, %r9d
jge 0x72aa
movl 0x13235(%rip), %eax     # 0x1a4c0
addl %r9d, %eax
addl $0x1f5, %eax            # imm = 0x1F5
movl $0x1f4, %r11d           # imm = 0x1F4
cltd
idivl %r11d
movslq %edx, %rax
leaq (%r8,%rax,8), %rax
addq $0x18, %rax
jmp 0x72b8
movslq %r9d, %rax
shlq $0x3, %rax
addq 0x12258(%rip), %rax     # 0x19510
movq (%rax), %rax
shlq $0x4, %r10
testb $0x1, -0xb(%rax,%r10)
jne 0x731c
movslq %r9d, %r10
shlq $0x3, %r10
addq 0x1223b(%rip), %r10     # 0x19510
movl 0x131e5(%rip), %eax     # 0x1a4c0
addl %r9d, %eax
addl $0x1f5, %eax            # imm = 0x1F5
movl $0x1f4, %r9d            # imm = 0x1F4
cltd
idivl %r9d
cmpl %esi, %edi
movslq %edx, %rax
leaq 0x18(%r8,%rax,8), %rax
cmovgeq %r10, %rax
movl %ecx, %edx
sarl $0x1f, %edx
andl %ecx, %edx
testl %ecx, %ecx
jle 0x731a
movq (%rax), %rsi
movl %ecx, %edi
shlq $0x4, %rdi
cmpl $0x20, -0x10(%rsi,%rdi)
jne 0x731c
decl %ecx
jmp 0x7302
movl %edx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
	static char buf[BUFSIZ];
	static int buflen = 0;
	int ret, written;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x12d21(%rip)     # 0x1a528
je 0x7810
pushq $0x1
popq %rbx
xorl %esi, %esi
jmp 0x784c
movl 0x12d0a(%rip), %edi     # 0x1a520
movslq 0x14d13(%rip), %rax     # 0x1c530
leaq 0x12d0c(%rip), %rsi     # 0x1a530
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x61e0
cmpl $-0x1, %eax
je 0x7894
testl %eax, %eax
je 0x78b1
xorl %esi, %esi
cmpb $0x0, 0x12ce2(%rip)     # 0x1a528
cmovel %eax, %esi
movslq %eax, %rbx
addl 0x14cde(%rip), %esi     # 0x1c530
movl %esi, 0x14cd8(%rip)     # 0x1c530
leaq 0x12cd1(%rip), %r14     # 0x1a530
movq %r14, %rdi
xorl %edx, %edx
callq 0x78b8
movl 0x14cc1(%rip), %ecx     # 0x1c530
subl %eax, %ecx
movl %ecx, 0x14cb9(%rip)     # 0x1c530
jle 0x7889
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x6530
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x65c0
movl (%rax), %edi
callq 0x6470
leaq 0x9dc3(%rip), %rdi      # 0x1166a
movq %rax, %rsi
xorl %eax, %eax
callq 0x6b5a
xorl %edi, %edi
callq 0x6190
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: twrite
int
twrite(const char *buf, int buflen, int show_ctrl)
{
	int charsize;
	Rune u;
	int n;

	int su0 = su;
	twrite_aborted = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movb 0x11bee(%rip), %bl      # 0x194c0
movb $0x0, 0x12c4f(%rip)     # 0x1a528
xorb $0x1, %bl
xorl %r15d, %r15d
movl %ebp, %eax
subl %r15d, %eax
jle 0x79ad
movslq %r15d, %rdi
addq %r14, %rdi
testb $0x40, 0x12c05(%rip)    # 0x1a4fc
jne 0x7907
movzbl (%rdi), %eax
movl %eax, (%rsp)
pushq $0x1
popq %rax
movl %eax, %r12d
jmp 0x791e
movslq %eax, %rdx
movq %rsp, %rsi
callq 0x9589
movq %rax, %r12
testl %r12d, %r12d
je 0x79ad
movb 0x11b9c(%rip), %al      # 0x194c0
orb %bl, %al
testb $0x1, %al
je 0x79a6
movl (%rsp), %r13d
cmpl $0x0, 0x4(%rsp)
je 0x7996
cmpl $0x20, %r13d
setae %al
cmpl $0x7f, %r13d
setne %cl
movl %r13d, %edx
andl $-0x20, %edx
cmpl $0x80, %edx
setne %dl
andb %cl, %dl
testb %al, %dl
jne 0x7996
cmpl $0x80, %r13d
jae 0x797e
cmpl $0xd, %r13d
ja 0x7972
movl $0x2600, %eax           # imm = 0x2600
btl %r13d, %eax
jb 0x7996
xorl $0x40, %r13d
movl %r13d, (%rsp)
pushq $0x5e
jmp 0x7990
andl $0x7f, %r13d
movl %r13d, (%rsp)
pushq $0x5e
popq %rdi
callq 0x9aad
pushq $0x5b
popq %rdi
callq 0x9aad
movl %r13d, %edi
callq 0x9aad
addl %r12d, %r15d
jmp 0x78df
movb $0x1, 0x12b7b(%rip)     # 0x1a528
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: selscroll
void
selscroll(int orig, int n)
{
	if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
		return;

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

// Assembly:
cmpl $-0x1, 0x111b9(%rip)    # 0x194f4
je 0x83d8
movl 0x111bd(%rip), %eax     # 0x19504
btl $0x2, 0x121ad(%rip)     # 0x1a4fc
sbbl $0x0, %eax
jne 0x83d8
movl 0x1118a(%rip), %ecx     # 0x194e8
cmpl %edi, %ecx
setge %dl
movl 0x1218f(%rip), %eax     # 0x1a4f8
cmpl %eax, %ecx
setle %cl
andb %dl, %cl
movl 0x1117a(%rip), %edx     # 0x194f0
cmpl %edi, %edx
setl %dil
cmpl %eax, %edx
setg %dl
orb %dil, %dl
cmpb %dl, %cl
je 0x6d9a
testb %cl, %cl
je 0x83d8
movl 0x11162(%rip), %ecx     # 0x194f8
addl %esi, %ecx
movl %ecx, 0x1115a(%rip)     # 0x194f8
addl 0x1115c(%rip), %esi     # 0x19500
movl %esi, 0x11156(%rip)     # 0x19500
movl 0x12144(%rip), %edx     # 0x1a4f4
cmpl %edx, %ecx
jl 0x6d9a
cmpl %eax, %ecx
setg %cl
cmpl %edx, %esi
setl %dl
cmpl %eax, %esi
setg %al
orb %cl, %al
orb %dl, %al
cmpb $0x1, %al
je 0x6d9a
jmp 0x6dc3
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: osc4_color_response
void
osc4_color_response(int num)
{
	int n;
	char buf[32];
	unsigned char r, g, b;

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

	n = snprintf(buf, sizeof buf, "\033]4;%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
		     num, r, r, g, g, b, b);

	ttywrite(buf, n, 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
callq 0xbf90
testl %eax, %eax
jne 0x8496
movzbl 0xf(%rsp), %r8d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
leaq 0x9273(%rip), %rdx      # 0x116d0
leaq 0x10(%rsp), %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
movl %r8d, %r9d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
callq 0x60b0
addq $0x20, %rsp
movslq %eax, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x79bf
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0xfb53(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x9202(%rip), %rsi      # 0x116a9
movl %ebx, %edx
xorl %eax, %eax
callq 0x68d0
jmp 0x848e
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: osc_color_response
void
osc_color_response(int index, int num)
{
	int n;
	char buf[32];
	unsigned char r, g, b;

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

	n = snprintf(buf, sizeof buf, "\033]%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
		     num, r, r, g, g, b, b);

	ttywrite(buf, n, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
callq 0xbf90
testl %eax, %eax
jne 0x8529
movzbl 0xf(%rsp), %r8d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
leaq 0x922e(%rip), %rdx      # 0x1171d
leaq 0x10(%rsp), %r14
pushq $0x20
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
movl %r8d, %r9d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
callq 0x60b0
addq $0x20, %rsp
movslq %eax, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x79bf
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xfac0(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x91bd(%rip), %rsi      # 0x116f7
movl %ebp, %edx
xorl %eax, %eax
callq 0x68d0
jmp 0x8520
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: drawregion
void
drawregion(int x1, int y1, int x2, int y2)
{
	int y;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %edi, %r14
movslq %edx, %r15
leaq (,%r14,8), %r12
leaq 0x1062b(%rip), %r13     # 0x19508
movl $0x1f4, %ebp            # imm = 0x1F4
cmpq %r15, %r14
jge 0x8f52
movq 0x115da(%rip), %rax     # 0x1a4c8
cmpl $0x0, (%rax,%r14,4)
je 0x8f49
andl $0x0, (%rax,%r14,4)
movslq 0x115c3(%rip), %rcx     # 0x1a4c4
cmpq %rcx, %r14
jge 0x8f29
movl 0x115b4(%rip), %eax     # 0x1a4c0
subl %ecx, %eax
addl %r14d, %eax
addl $0x1f5, %eax            # imm = 0x1F5
cltd
idivl %ebp
movslq %edx, %rax
leaq 0x18(,%rax,8), %rax
addq %r13, %rax
jmp 0x8f3a
movq 0x105e0(%rip), %rax     # 0x19510
shlq $0x3, %rcx
subq %rcx, %rax
addq %r12, %rax
movq (%rax), %rdi
xorl %esi, %esi
movl %r14d, %edx
movl %ebx, %ecx
callq 0xc4cc
incq %r14
addq $0x8, %r12
jmp 0x8ee2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: tsetcolor
void
tsetcolor( int row, int start, int end, uint32_t fg, uint32_t bg )
{
	int i = start;
	for( ; i < end; ++i )
	{
		term.line[row][i].fg = fg;
		term.line[row][i].bg = bg;
	}
}

// Assembly:
movq 0x1030f(%rip), %rax     # 0x19510
movslq %edi, %rdi
movslq %esi, %rsi
movslq %edx, %rdx
movq %rsi, %r9
shlq $0x4, %r9
orq $0xc, %r9
cmpq %rdx, %rsi
jge 0x9230
movq (%rax,%rdi,8), %r10
movl %ecx, -0x4(%r10,%r9)
movl %r8d, (%r10,%r9)
incq %rsi
addq $0x10, %r9
jmp 0x9215
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: select_or_drawcursor
void select_or_drawcursor(int selectsearch_mode, int type) {
	int done = 0;

	if ( selectsearch_mode & 1 ) {
		selextend(term.c.x, term.c.y, type, done);
		xsetsel(getsel());
	}
	else
		xdrawcursor(term.c.x, term.c.y, term.line[term.c.y][term.c.x],
			    term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
}

// Assembly:
subq $0x28, %rsp
movl %esi, %edx
movl %edi, %eax
movslq 0x110c0(%rip), %rdi     # 0x1a4e0
movslq 0x110bd(%rip), %rsi     # 0x1a4e4
testb $0x1, %al
jne 0x947c
movq 0x100de(%rip), %rax     # 0x19510
movq (%rax,%rsi,8), %rcx
movq %rdi, %r10
shlq $0x4, %r10
movslq 0x110a8(%rip), %r8      # 0x1a4ec
movslq 0x110a5(%rip), %r9      # 0x1a4f0
movq (%rax,%r9,8), %rax
movq %r8, %r11
shlq $0x4, %r11
movq (%rcx,%r10), %rdx
movq 0x8(%rcx,%r10), %rcx
movups (%rax,%r11), %xmm0
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xc049
addq $0x28, %rsp
retq
xorl %ecx, %ecx
callq 0x6f03
callq 0x706f
movq %rax, %rdi
addq $0x28, %rsp
jmp 0xbcdf
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: search
void search(int selectsearch_mode, Rune *target, int ptarget, int incr, int type, TCursor *cu) {
	Rune *r;
	int i, bound = (term.col * cu->y + cu->x) * (incr > 0) + incr;

	for (i = term.col * term.c.y + term.c.x + incr; i != bound; i += incr) {
		for (r = target; r - target < ptarget; r++) {
			if ( *r == term.line[(i + r - target) / term.col][(i + r - target) % term.col].u ) {
				if ( r - target == ptarget - 1 )     break;
			} else {
				r = NULL;
				break;
			}
		}
		if ( r != NULL )    break;
	}

	if ( i != bound ) {
		term.c.y = i / term.col, term.c.x = i % term.col;
		select_or_drawcursor(selectsearch_mode, type);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, -0x4(%rsp)
movl %edi, -0x8(%rsp)
movslq 0x1005e(%rip), %r10     # 0x1950c
movl 0x14(%r9), %eax
imull %r10d, %eax
addl 0x10(%r9), %eax
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %eax
movl 0x1101a(%rip), %r8d     # 0x1a4e4
imull %r10d, %r8d
addl 0x1100b(%rip), %r8d     # 0x1a4e0
movslq %edx, %r11
movq 0x10031(%rip), %rbx     # 0x19510
leal -0x1(%r11), %edx
movslq %edx, %r14
movslq %r8d, %r9
movslq %ecx, %rcx
movslq %eax, %r15
leaq (,%rcx,4), %rdi
leaq (,%r9,4), %rax
leaq (%rax,%rcx,4), %r13
cmpq %r15, %r9
je 0x957e
addq %rcx, %r9
xorl %r12d, %r12d
movq %r12, %rbp
sarq $0x2, %rbp
cmpq %r11, %rbp
jge 0x9544
movl (%rsi,%r12), %r8d
leaq (%r12,%r13), %rax
sarq $0x2, %rax
cqto
idivq %r10
movq (%rbx,%rax,8), %rax
shlq $0x4, %rdx
cmpl (%rax,%rdx), %r8d
jne 0x9549
cmpq %r14, %rbp
je 0x9554
addq $0x4, %r12
jmp 0x950e
addq %rsi, %r12
jmp 0x954c
xorl %r12d, %r12d
addq %rdi, %r13
testq %r12, %r12
je 0x9503
movl %r9d, %eax
cltd
idivl %r10d
movl %eax, 0x10f83(%rip)     # 0x1a4e4
movl %edx, 0x10f79(%rip)     # 0x1a4e0
movl -0x8(%rsp), %edi
movl -0x4(%rsp), %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9411
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/st.c
// Function: utf8decode
size_t
utf8decode(const char *c, Rune *u, size_t clen)
{
    size_t i, j, len, type;
    Rune udecoded;

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

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xfffd, (%rsi)         # imm = 0xFFFD
testq %rdx, %rdx
je 0x9617
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movsbl (%rdi), %edi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0xbc3b
movl %eax, %ebp
movq (%rbx), %r14
leaq -0x1(%r14), %rax
cmpq $0x3, %rax
ja 0x960c
movq %r13, (%rsp)
decq %r15
cmpq %r15, %rax
cmovbq %rax, %r15
negq %r15
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %r13
leaq (%r15,%rbx), %rax
cmpq $0x1, %rax
je 0x9612
movsbl (%r12,%rbx), %edi
movq %r13, %rsi
callq 0xbc3b
cmpq $0x0, 0x8(%rsp)
jne 0x961c
shll $0x6, %ebp
orl %eax, %ebp
incq %rbx
jmp 0x95e3
pushq $0x1
popq %r14
jmp 0x962f
cmpq %r14, %rbx
jae 0x9621
xorl %r14d, %r14d
jmp 0x962f
movq %rbx, %r14
jmp 0x962f
movq (%rsp), %rdi
movl %ebp, (%rdi)
movq %r14, %rsi
callq 0x6cb9
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[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;
	}

	if (term.scr > 0 && term.scr < HISTSIZE)
		term.scr = MIN(term.scr + n, HISTSIZE-1);

	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;
	}

	if (term.scr == 0)
		selscroll(orig, -n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
js 0xb64c
movl 0xeebb(%rip), %r14d     # 0x1a4f8
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xb64f
xorl %r14d, %r14d
movslq %ebx, %r15
testl %edx, %edx
je 0xb696
leaq 0xdeab(%rip), %rcx      # 0x19508
movl 0xee5d(%rip), %eax      # 0x1a4c0
incl %eax
movl $0x1f4, %esi            # imm = 0x1F4
cltd
idivl %esi
movl %edx, 0xee4d(%rip)      # 0x1a4c0
movslq %edx, %rax
movq 0x18(%rcx,%rax,8), %rdx
movq 0xde8e(%rip), %rsi      # 0x19510
movq (%rsi,%r15,8), %rsi
movq %rsi, 0x18(%rcx,%rax,8)
movq 0xde7e(%rip), %rax      # 0x19510
movq %rdx, (%rax,%r15,8)
movl 0xee28(%rip), %eax      # 0x1a4c4
leal -0x1(%rax), %ecx
cmpl $0x1f2, %ecx            # imm = 0x1F2
ja 0xb6ba
addl %r14d, %eax
movl $0x1f3, %ecx            # imm = 0x1F3
cmpl %ecx, %eax
cmovgel %ecx, %eax
movl %eax, 0xee0a(%rip)      # 0x1a4c4
movl 0xde4c(%rip), %edx      # 0x1950c
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x8baf
movl 0xee1d(%rip), %esi      # 0x1a4f8
movl %ebp, %edi
callq 0x6ebb
movslq 0xee0f(%rip), %rax      # 0x1a4f8
movslq %r14d, %rcx
subq %rcx, %rax
shlq $0x3, %rcx
cmpq %rax, %r15
jg 0xb722
movq 0xde11(%rip), %rdx      # 0x19510
leaq (%rdx,%r15,8), %rsi
movq (%rdx,%r15,8), %rdi
movq (%rcx,%rsi), %rsi
movq %rsi, (%rdx,%r15,8)
movq 0xddfa(%rip), %rdx      # 0x19510
addq %rcx, %rdx
movq %rdi, (%rdx,%r15,8)
incq %r15
jmp 0xb6f3
cmpl $0x0, 0xed9b(%rip)      # 0x1a4c4
je 0xb736
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8334
// File: /workspace/github_c_makefile_star2_O2/mrdotx[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;
	}

	if (term.scr == 0)
		selscroll(orig, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movl %edi, %ebx
movslq 0xed9c(%rip), %rsi      # 0x1a4f8
testl %eax, %eax
js 0xb772
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0xb775
xorl %r14d, %r14d
testl %edx, %edx
je 0xb7bc
leaq 0xdd88(%rip), %rcx      # 0x19508
movl $0x1f3, %eax            # imm = 0x1F3
addl 0xed35(%rip), %eax      # 0x1a4c0
movl $0x1f4, %edi            # imm = 0x1F4
cltd
idivl %edi
movl %edx, 0xed27(%rip)      # 0x1a4c0
movslq %edx, %rax
movq 0x18(%rcx,%rax,8), %rdx
movq 0xdd68(%rip), %rdi      # 0x19510
movq (%rdi,%rsi,8), %rdi
movq %rdi, 0x18(%rcx,%rax,8)
movq 0xdd58(%rip), %rax      # 0x19510
movq %rdx, (%rax,%rsi,8)
subl %r14d, %esi
movl %ebx, %edi
callq 0x6ebb
movl 0xed2c(%rip), %ecx      # 0x1a4f8
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0xdd33(%rip), %edx      # 0x1950c
decl %edx
xorl %edi, %edi
callq 0x8baf
movslq 0xed0f(%rip), %rax      # 0x1a4f8
leal (%r14,%rbx), %ecx
movslq %ecx, %rcx
movslq %r14d, %rdx
shlq $0x3, %rdx
negq %rdx
cmpq %rcx, %rax
jl 0xb829
movq 0xdd0a(%rip), %rsi      # 0x19510
leaq (%rsi,%rax,8), %rdi
movq (%rsi,%rax,8), %r8
movq (%rdx,%rdi), %rdi
movq %rdi, (%rsi,%rax,8)
movq 0xdcf3(%rip), %rsi      # 0x19510
addq %rdx, %rsi
movq %r8, (%rsi,%rax,8)
decq %rax
jmp 0xb7fa
cmpl $0x0, 0xec94(%rip)      # 0x1a4c4
je 0xb83a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8334
// File: /workspace/github_c_makefile_star2_O2/mrdotx[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)
			XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
	} 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);
		}

	/* set alpha value of bg color */
	if (opt_alpha)
		alpha = strtof(opt_alpha, NULL);
	dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);
	dc.col[defaultbg].pixel &= 0x00FFFFFF;
	dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;
	loaded = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x10c99(%rip)     # 0x1c9f0
jne 0xbda0
movq 0x10c98(%rip), %rax     # 0x1c9f8
movq %rax, %rbx
movq 0x10c96(%rip), %rcx     # 0x1ca00
shlq $0x4, %rcx
addq %rax, %rcx
cmpq %rcx, %rbx
jae 0xbdbc
movq 0x10d73(%rip), %rdi     # 0x1caf0
movq 0x10de4(%rip), %rsi     # 0x1cb68
movq 0x10d6d(%rip), %rdx     # 0x1caf8
movq %rbx, %rcx
callq 0x6600
addq $0x10, %rbx
movq 0x10c5a(%rip), %rax     # 0x1c9f8
jmp 0xbd63
movq $0x103, 0x10c55(%rip) # imm = 0x103
movl $0x1030, %edi           # imm = 0x1030
callq 0x6b30
movq %rax, 0x10c3c(%rip)     # 0x1c9f8
leaq 0xc80d(%rip), %r12      # 0x185d0
leaq 0x608a(%rip), %rbx      # 0x11e54
leaq 0x6064(%rip), %r14      # 0x11e35
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, 0x10c22(%rip)     # 0x1ca00
jbe 0xbe27
movq 0x10c11(%rip), %rdx     # 0x1c9f8
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xbea5
testl %eax, %eax
jne 0xbe1a
movq (%r12), %rsi
testq %rsi, %rsi
je 0xbe0d
movq %r14, %rdi
xorl %eax, %eax
callq 0x6b5a
jmp 0xbe1a
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x6b5a
incq %r15
addq $0x10, %r13
addq $0x8, %r12
jmp 0xbdd7
movq 0x10dca(%rip), %rdi     # 0x1cbf8
testq %rdi, %rdi
je 0xbe44
xorl %esi, %esi
callq 0x6480
movss %xmm0, 0xc74a(%rip)     # 0x1858c
jmp 0xbe4c
movss 0xc740(%rip), %xmm0     # 0x1858c
movss 0x5d74(%rip), %xmm1     # 0x11bc8
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movq 0x10b95(%rip), %rcx     # 0x1c9f8
movl 0xc72b(%rip), %edx      # 0x18594
shlq $0x4, %rdx
movw %ax, 0xe(%rcx,%rdx)
movq (%rcx,%rdx), %rax
mulss 0x5d4e(%rip), %xmm0     # 0x11bcc
andl $0xffffff, %eax         # imm = 0xFFFFFF
cvttss2si %xmm0, %esi
shll $0x18, %esi
movslq %esi, %rsi
orq %rax, %rsi
movq %rsi, (%rcx,%rdx)
movb $0x1, 0x10b55(%rip)     # 0x1c9f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xloadcolor
int
xloadcolor(int i, const char *name, Color *ncolor)
{
	XRenderColor color = { .alpha = 0xffff };

	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;
			}
			return XftColorAllocValue(xw.dpy, xw.vis,
			                          xw.cmap, &color, ncolor);
		} else
			name = colorname[i];
	}

	return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor);
}

// Assembly:
pushq %rax
movq %rdx, %r8
movq %rsi, %rcx
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, (%rsp)
testq %rsi, %rsi
jne 0xbf3b
leal -0x10(%rdi), %esi
cmpl $0xef, %esi
ja 0xbf2d
cmpl $0xe7, %edi
ja 0xbf56
movzbl %sil, %ecx
movb $0x24, %dl
movl %ecx, %eax
divb %dl
movzbl %al, %eax
imull $0x2828, %eax, %edx     # imm = 0x2828
movl $0x3737, %edi           # imm = 0x3737
addl %edi, %edx
xorl %r9d, %r9d
cmpl $0x24, %esi
cmovbl %r9d, %edx
movb $0x6, %sil
movl %ecx, %eax
divb %sil
movzbl %ah, %ecx
movzbl %al, %eax
divb %sil
movzbl %ah, %esi
imull $0x2828, %esi, %eax     # imm = 0x2828
addl %edi, %eax
testb %sil, %sil
cmovel %r9d, %eax
imull $0x2828, %ecx, %esi     # imm = 0x2828
addl %edi, %esi
testb %cl, %cl
cmovel %r9d, %esi
jmp 0xbf66
movslq %edi, %rax
leaq 0xc699(%rip), %rcx      # 0x185d0
movq (%rcx,%rax,8), %rcx
movq 0x10bae(%rip), %rdi     # 0x1caf0
movq 0x10c1f(%rip), %rsi     # 0x1cb68
movq 0x10ba8(%rip), %rdx     # 0x1caf8
popq %rax
jmp 0x6520
imull $0xa0a, %edi, %edx      # imm = 0xA0A
addl $0xffffeef8, %edx       # imm = 0xFFFFEEF8
movl %edx, %eax
movl %edx, %esi
movq %rsp, %rcx
movw %dx, (%rcx)
movw %ax, 0x2(%rcx)
movw %si, 0x4(%rcx)
movq 0x10b75(%rip), %rdi     # 0x1caf0
movq 0x10be6(%rip), %rsi     # 0x1cb68
movq 0x10b6f(%rip), %rdx     # 0x1caf8
callq 0x6720
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[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 - 1))
		return 1;

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

	return 0;
}

// Assembly:
pushq $0x1
popq %rax
testl %edi, %edi
js 0xbfd5
movl %edi, %edi
movq 0x10a60(%rip), %r8      # 0x1ca00
decq %r8
cmpq %rdi, %r8
jb 0xbfd5
movq 0x10a49(%rip), %rax     # 0x1c9f8
shlq $0x4, %rdi
movb 0x9(%rax,%rdi), %al
movb %al, (%rsi)
movq 0x10a38(%rip), %rax     # 0x1c9f8
movb 0xb(%rax,%rdi), %al
movb %al, (%rdx)
movq 0x10a2b(%rip), %rax     # 0x1c9f8
movb 0xd(%rax,%rdi), %al
movb %al, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xsetcolorname
int
xsetcolorname(int x, const char *name)
{
	Color ncolor;

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

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

	XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]);
	dc.col[x] = ncolor;

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
pushq $0x1
popq %rbx
testl %edi, %edi
js 0xc03f
movl %edi, %r14d
movq 0x10a12(%rip), %rax     # 0x1ca00
decq %rax
cmpq %r14, %rax
jb 0xc03f
leaq 0x8(%rsp), %rdx
callq 0xbea5
testl %eax, %eax
je 0xc03f
movq 0x10ae5(%rip), %rdi     # 0x1caf0
movq 0x10b56(%rip), %rsi     # 0x1cb68
movq 0x10adf(%rip), %rdx     # 0x1caf8
shlq $0x4, %r14
movq 0x109d4(%rip), %rcx     # 0x1c9f8
addq %r14, %rcx
callq 0x6600
movq 0x109c5(%rip), %rax     # 0x1c9f8
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rax,%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (p[0] == '\0')
		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 %rbx
subq $0x30, %rsp
testq %rdi, %rdi
movq 0x108ae(%rip), %rax     # 0x1cc20
cmoveq %rax, %rdi
cmpb $0x0, (%rdi)
cmoveq %rax, %rdi
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x10764(%rip), %rdi     # 0x1caf0
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x10(%rsp), %r8
callq 0x6440
testl %eax, %eax
jne 0xc3e0
movq 0x10749(%rip), %rdi     # 0x1caf0
movq 0x10752(%rip), %rsi     # 0x1cb00
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6340
movq 0x1072e(%rip), %rdi     # 0x1caf0
movq 0x10737(%rip), %rsi     # 0x1cb00
movq 0x10760(%rip), %rcx     # 0x1cb30
movq %rbx, %rdx
callq 0x6460
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (p[0] == '\0')
		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 %rbx
subq $0x30, %rsp
testq %rdi, %rdi
movq 0x1082b(%rip), %rax     # 0x1cc20
cmoveq %rax, %rdi
cmpb $0x0, (%rdi)
cmoveq %rax, %rdi
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x106e1(%rip), %rdi     # 0x1caf0
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x10(%rsp), %r8
callq 0x6440
testl %eax, %eax
jne 0xc463
movq 0x106c6(%rip), %rdi     # 0x1caf0
movq 0x106cf(%rip), %rsi     # 0x1cb00
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6400
movq 0x106ab(%rip), %rdi     # 0x1caf0
movq 0x106b4(%rip), %rsi     # 0x1cb00
movq 0x106d5(%rip), %rcx     # 0x1cb28
movq %rbx, %rdx
callq 0x6460
movq (%rbx), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
	if (xw.ime.xic == NULL)
		return;

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

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

// Assembly:
movl %edi, %eax
movq 0xfaaf(%rip), %rdi      # 0x1cb48
testq %rdi, %rdi
je 0xd0dd
movl 0xbd60(%rip), %ecx      # 0x18e04
imull 0xfb69(%rip), %eax      # 0x1cc14
addl %ecx, %eax
movw %ax, 0xfa9c(%rip)       # 0x1cb50
incl %esi
imull 0xfb53(%rip), %esi      # 0x1cc10
addl %ecx, %esi
movw %si, 0xfa8c(%rip)       # 0x1cb52
movq 0xfa8b(%rip), %rdx      # 0x1cb58
leaq 0x4d9d(%rip), %rsi      # 0x11e71
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x6290
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: config_init
void
config_init(void)
{
	char *resm;
	XrmDatabase db;
	ResourcePref *p;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x6570
movq 0xf7c1(%rip), %rdi      # 0x1caf0
callq 0x6180
testq %rax, %rax
je 0xd373
movq %rax, %rdi
callq 0x66c0
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0xbac2(%rip), %r15      # 0x18e10
cmpq $0x32f, %r14            # imm = 0x32F
ja 0xd373
movq (%r14,%r15), %rsi
movl 0x8(%r14,%r15), %edx
movq 0x10(%r14,%r15), %rcx
movq %rbx, %rdi
callq 0xd1e6
addq $0x18, %r14
jmp 0xd34e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: opencopied
void
opencopied(const Arg *arg)
{
	size_t const max_cmd = 2048;
	char * const clip = xsel.clipboard;
	if(!clip) {
		fprintf(stderr, "Warning: nothing copied to clipboard\n");
		return;
	}

	/* account for space/quote (3) and \0 (1) and & (1) */
	/* e.g.: xdg-open "https://st.suckless.org"& */
	size_t const cmd_size = max_cmd + strlen(clip) + 5;
	char cmd[cmd_size];

	snprintf(cmd, cmd_size, "%s \"%s\"&", (char *)arg->v, clip);
	system(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xeaa7(%rip), %rbx      # 0x1cc78
testq %rbx, %rbx
je 0xe22d
movq %rdi, %r14
movq %rbx, %rdi
callq 0x6390
movq %rsp, %r12
leaq 0x805(%rax), %rsi
movq %rsp, %r15
addq $0x814, %rax            # imm = 0x814
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq (%r14), %rcx
leaq 0x3cd2(%rip), %rdx      # 0x11eda
movq %r15, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x60b0
movq %r15, %rdi
callq 0x6220
movq %r12, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x9dbc(%rip), %rax      # 0x17ff0
movq (%rax), %rcx
leaq 0x3c76(%rip), %rdi      # 0x11eb4
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6860
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: ximopen
int
ximopen(Display *dpy)
{
	XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };
	XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };

	xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);
	if (xw.ime.xim == NULL)
		return 0;

	if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL))
		fprintf(stderr, "XSetIMValues: "
		                "Could not set XNDestroyCallback.\n");

	xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot,
	                                      NULL);

	if (xw.ime.xic == NULL) {
		xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle,
		                       XIMPreeditNothing | XIMStatusNothing,
		                       XNClientWindow, xw.win,
		                       XNDestroyCallback, &icdestroy,
		                       NULL);
	}
	if (xw.ime.xic == NULL)
		fprintf(stderr, "XCreateIC: Could not create input context.\n");

	return 1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movups 0x7a91(%rip), %xmm0     # 0x16230
movaps %xmm0, 0x20(%rsp)
movups 0x7a95(%rip), %xmm0     # 0x16240
movaps %xmm0, 0x10(%rsp)
movq 0xe339(%rip), %rdi      # 0x1caf0
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x66e0
movq %rax, 0xe375(%rip)      # 0x1cb40
testq %rax, %rax
je 0xe868
leaq 0x3a8a(%rip), %rsi      # 0x12265
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x65f0
testq %rax, %rax
jne 0xe870
leaq 0x3aad(%rip), %rsi      # 0x122a5
leaq 0xe351(%rip), %rdx      # 0x1cb50
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x6710
movq %rax, 0xe347(%rip)      # 0x1cb58
pushq $0x1
popq %rbx
cmpq $0x0, 0xe32c(%rip)      # 0x1cb48
jne 0xe868
movq 0xe31b(%rip), %rdi      # 0x1cb40
movq 0xe2d4(%rip), %r8       # 0x1cb00
andq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x3a70(%rip), %rsi      # 0x122b2
leaq 0x3a74(%rip), %rcx      # 0x122bd
leaq 0x3a15(%rip), %r9       # 0x12265
movl $0x408, %edx            # imm = 0x408
xorl %eax, %eax
callq 0x6030
movq %rax, 0xe2e5(%rip)      # 0x1cb48
testq %rax, %rax
je 0xe891
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq 0x9779(%rip), %rax      # 0x17ff0
movq (%rax), %rcx
leaq 0x39f4(%rip), %rdi      # 0x12275
pushq $0x2f
popq %rsi
pushq $0x1
popq %rdx
callq 0x6860
jmp 0xe7f1
movq 0x9758(%rip), %rax      # 0x17ff0
movq (%rax), %rcx
leaq 0x3a28(%rip), %rdi      # 0x122ca
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
callq 0x6860
jmp 0xe868
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xloadsparefont
int
xloadsparefont(FcPattern *pattern, int flags)
{
	FcPattern *match;
	FcResult result;
	
	match = FcFontMatch(NULL, pattern, &result);
	if (!match) {
		return 1;
	}

	if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
		FcPatternDestroy(match);
		return 1;
	}

	frc[frclen].flags = flags;
	/* Believe U+0000 glyph will present in each default font */
	frc[frclen].unicodep = 0;
	frclen++;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0xc(%rsp), %rdx
xorl %edi, %edi
callq 0x61b0
pushq $0x1
popq %rbp
testq %rax, %rax
je 0xec85
movq %rax, %r14
movq 0xdeae(%rip), %rdi      # 0x1caf0
movq %rax, %rsi
callq 0x67b0
movq 0xe057(%rip), %rdx      # 0x1cca8
movslq 0xe048(%rip), %rcx      # 0x1cca0
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
testq %rax, %rax
je 0xec7d
movl %ebx, 0x8(%rdx,%rsi)
andl $0x0, 0xc(%rdx,%rsi)
incl %ecx
movl %ecx, 0xe027(%rip)      # 0x1cca0
xorl %ebp, %ebp
jmp 0xec85
movq %r14, %rdi
callq 0x6050
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: zoomabs
void
zoomabs(const Arg *arg)
{
	xunloadfonts();
	xloadfonts(usedfont, arg->f);
	xloadsparefonts();
	cresize(0, 0);
	redraw();
	xhints();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xd503(%rip), %eax      # 0x1cca0
testl %eax, %eax
jle 0xf7c6
movq 0xd348(%rip), %rdi      # 0x1caf0
movq 0xd4f9(%rip), %rcx      # 0x1cca8
decl %eax
movl %eax, 0xd4e9(%rip)      # 0x1cca0
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x60d0
jmp 0xf797
leaq 0xd23b(%rip), %rdi      # 0x1ca08
callq 0xf81f
leaq 0xd267(%rip), %rdi      # 0x1ca40
callq 0xf81f
leaq 0xd293(%rip), %rdi      # 0x1ca78
callq 0xf81f
leaq 0xd2bf(%rip), %rdi      # 0x1cab0
callq 0xf81f
movq 0xd4bb(%rip), %rdi      # 0x1ccb8
cvtss2sd (%rbx), %xmm0
callq 0xe297
callq 0xe53b
xorl %edi, %edi
xorl %esi, %esi
callq 0xecce
callq 0x8f61
popq %rbx
jmp 0xe8d8
// File: /workspace/github_c_makefile_star2_O2/mrdotx[P]st/x.c
// Function: xunloadfont
void
xunloadfont(Font *f)
{
	XftFontClose(xw.dpy, f->match);
	FcPatternDestroy(f->pattern);
	if (f->set)
		FcFontSetDestroy(f->set);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd2c6(%rip), %rdi      # 0x1caf0
movq 0x20(%rbx), %rsi
callq 0x60d0
movq 0x30(%rbx), %rdi
callq 0x6050
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf84b
popq %rbx
jmp 0x64f0
popq %rbx
retq