LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: selftest
static int
selftest(void)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	char hbuf_hex[33];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing MD5 of \"%s\"...", tests[i].s);
		MD5_Init(&ctx);
		MD5_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		MD5_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 16);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed MD5: %s\n", hbuf_hex);
			printf("Correct MD5:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl $0x8, %ebx
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
leaq 0x53f9(%rip), %rax      # 0x6d60
movq -0x8(%rbx,%rax), %rbp
movq (%rbx,%rax), %r13
leaq 0x2750(%rip), %rdi      # 0x40c7
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x2040
movq %rbp, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x2053
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2877
movl $0x10, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x31b4
movq %r12, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x19ff
leaq 0x2a33(%rip), %rdi      # 0x4406
callq 0x1090
leaq 0x2701(%rip), %rdi      # 0x40e0
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x2702(%rip), %rdi      # 0x40f2
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x1a0b
leaq 0x29f7(%rip), %rdi      # 0x43fd
callq 0x1090
addq $0x10, %rbx
cmpq $0x98, %rbx
jne 0x1960
xorl %eax, %eax
testq %r15, %r15
setne %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	MD5_Init(&ctx);
	for (i = 0; i < nreps; i++)
		MD5_Update(&ctx, buf, buflen);
	MD5_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %rdi
callq 0x2040
testq %rbx, %rbx
je 0x2022
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2053
decq %rbx
jne 0x200f
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2877
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
  static char buf[BUFSIZ];
  static int buflen = 0;
  int written;
  int ret;

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

  switch (ret) {
  case 0:
    fputs("Found EOF in input\n", stderr);
    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 uncomplete utf8 char for the next call */
    if (buflen > 0)
      memmove(buf, buf + written, buflen);
  }

  if (term.scr > 0 && (unsigned int)term.scr < (histsize - 1))
    term.scr++;

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x167e2(%rip)     # 0x1e720
je 0x7f49
movl $0x1, %ebx
xorl %esi, %esi
jmp 0x7f8d
movl 0x167c9(%rip), %edi     # 0x1e718
movslq 0x187da(%rip), %rax     # 0x20730
leaq 0x167d3(%rip), %rsi     # 0x1e730
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6200
cmpl $-0x1, %eax
je 0x7ff6
testl %eax, %eax
je 0x8013
xorl %esi, %esi
cmpb $0x0, 0x16799(%rip)     # 0x1e720
cmovel %eax, %esi
movslq %eax, %rbx
addl 0x1879d(%rip), %esi     # 0x20730
movl %esi, 0x18797(%rip)     # 0x20730
leaq 0x16790(%rip), %r14     # 0x1e730
movq %r14, %rdi
xorl %edx, %edx
callq 0x8018
movl 0x18780(%rip), %ecx     # 0x20730
subl %eax, %ecx
movl %ecx, 0x18778(%rip)     # 0x20730
jle 0x7fca
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x6580
movl 0x166ec(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x7feb
leaq 0x155a5(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
decl %ecx
cmpl %ecx, %eax
jae 0x7feb
incl %eax
movl %eax, 0x166d1(%rip)     # 0x1e6bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6620
movl (%rax), %edi
callq 0x64b0
leaq 0xa67f(%rip), %rdi      # 0x12688
movq %rax, %rsi
xorl %eax, %eax
callq 0x714f
callq 0x6ca2
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: kscrolldown
void
kscrolldown(const Arg* a)
{
  int n = a->i;

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

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

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

// Assembly:
movl 0x164b0(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x8358
pushq %rbx
movl (%rdi), %ecx
movl %ecx, %esi
sarl $0x1f, %esi
andl 0x16476(%rip), %esi     # 0x1e698
addl %ecx, %esi
cmpl %eax, %esi
cmovgel %eax, %esi
subl %esi, %eax
movl %eax, 0x1648b(%rip)     # 0x1e6bc
negl %esi
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x8cfe
movb $0x0, 0x1640d(%rip)     # 0x1e650
movl 0x1644f(%rip), %eax     # 0x1e698
decl %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
movq 0x16467(%rip), %rdx     # 0x1e6c0
movslq %ecx, %rcx
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
leaq 0x4(%rsi), %rax
andq $-0x4, %rax
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rcx,4), %rcx
addq $0xc, %rcx
movdqa 0x9d9b(%rip), %xmm1     # 0x12020
movdqa 0x9da3(%rip), %xmm2     # 0x12030
movdqa 0x9dab(%rip), %xmm3     # 0x12040
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rbx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0x82e7
movl $0x1, -0xc(%rcx,%rbx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x82fd
movl $0x1, -0x8(%rcx,%rbx,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edx
testb $0x1, %dl
je 0x8339
movl $0x1, -0x4(%rcx,%rbx,4)
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x834a
movl $0x1, (%rcx,%rbx,4)
addq $0x4, %rbx
cmpq %rbx, %rax
jne 0x829d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: ttyresize
void
ttyresize(int tw, int th)
{
  struct winsize w;

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

// Assembly:
pushq %rax
movq 0x1614e(%rip), %xmm0    # 0x1e698
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
movq %rsp, %rdx
movd %xmm0, (%rdx)
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
movl 0x161b4(%rip), %edi     # 0x1e718
movl $0x5414, %esi           # imm = 0x5414
xorl %eax, %eax
callq 0x6120
testl %eax, %eax
js 0x8576
popq %rax
retq
callq 0x6cc0
jmp 0x8574
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: tnew
void
tnew(int col, int row)
{
  term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };

  /* allocate history buffer */
  term.hist = (Line*)xrealloc(term.hist, (histsize+1) * sizeof(Line));
  bzero(term.hist, ((histsize+1) * sizeof(Line)));

  tresize(col, row);
  treset();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x14f49(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x14f3c(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x1602c(%rip)    # 0x1e6a8
movups %xmm0, 0x16015(%rip)    # 0x1e698
movups %xmm0, 0x1602e(%rip)    # 0x1e6b8
movq $0x0, 0x16033(%rip) # 0x1e6c8
movl %eax, 0x16035(%rip)     # 0x1e6d0
movl %ecx, 0x16033(%rip)     # 0x1e6d4
movups %xmm0, 0x16030(%rip)    # 0x1e6d8
movups %xmm0, 0x16039(%rip)    # 0x1e6e8
movups %xmm0, 0x16042(%rip)    # 0x1e6f8
movups %xmm0, 0x1604b(%rip)    # 0x1e708
movq 0x15fec(%rip), %rdi     # 0x1e6b0
leaq 0x14eb5(%rip), %r14     # 0x1d580
movl (%r14), %esi
incl %esi
shlq $0x3, %rsi
callq 0x71e9
movq %rax, 0x15fd0(%rip)     # 0x1e6b0
movl (%r14), %edx
incl %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x60c0
movl %ebp, %edi
movl %ebx, %esi
callq 0x8705
popq %rbx
popq %r14
popq %rbp
jmp 0x8b93
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: treset
void
treset(void)
{
  uint i;

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

  memset(term.tabs, 0, term.col * sizeof(*term.tabs));
  for (i = tabspaces; i < (unsigned int)term.col; i += tabspaces)
    term.tabs[i] = 1;

  term.top = 0;
  term.bot = term.row - 1;
  term.mode = MODE_WRAP|MODE_UTF8;
  memset(term.trantbl, CS_USA, sizeof(term.trantbl));
  term.charset = 0;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x14a13(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x14a06(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
movl $0x0, 0x15b16(%rip)     # 0x1e6c8
movw $0x0, 0x15b11(%rip)     # 0x1e6cc
movl %eax, 0x15b0f(%rip)     # 0x1e6d0
movl %ecx, 0x15b0d(%rip)     # 0x1e6d4
movq $0x0, 0x15b06(%rip) # 0x1e6d8
movb $0x0, 0x15b07(%rip)     # 0x1e6e0
movq 0x15b28(%rip), %rdi     # 0x1e708
movslq 0x15ab5(%rip), %rbx     # 0x1e69c
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60c0
leaq 0x149a4(%rip), %rax     # 0x1d5a0
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x8c1e
movq 0x15aff(%rip), %rdx     # 0x1e708
movl 0x15a8d(%rip), %esi     # 0x1e69c
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x8c0f
movl $0x0, 0x15ac4(%rip)     # 0x1e6ec
movl 0x15a6a(%rip), %eax     # 0x1e698
decl %eax
movl %eax, 0x15aba(%rip)     # 0x1e6f0
movl $0x41, 0x15ab4(%rip)    # 0x1e6f4
movq $0x3030303, 0x15ab1(%rip) # imm = 0x3030303
movb $0x1, %bpl
leaq 0x17deb(%rip), %rbx     # 0x20a40
movb 0x15a85(%rip), %dl      # 0x1e6e0
movl 0x15a37(%rip), %ecx     # 0x1e698
movl %edx, %eax
andb $-0x2, %al
movb %al, 0x15a75(%rip)      # 0x1e6e0
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x8c85
movl 0x15a71(%rip), %esi     # 0x1e6f0
movl 0x15a67(%rip), %eax     # 0x1e6ec
movl 0x15a11(%rip), %edx     # 0x1e69c
decl %edx
movl %esi, %edi
sarl $0x1f, %edi
andl %esi, %edi
movl %edx, %esi
sarl $0x1f, %esi
andl %edx, %esi
testl %eax, %eax
cmovgl %eax, %edi
movl %esi, 0x15a32(%rip)     # 0x1e6d8
movl %edi, 0x15a30(%rip)     # 0x1e6dc
movl 0x15a42(%rip), %eax     # 0x1e6f4
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0x159fe(%rip), %xmm0    # 0x1e6c8
movups %xmm0, (%rbx,%rsi)
movups 0x159ff(%rip), %xmm0    # 0x1e6d4
movups %xmm0, 0xc(%rbx,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x92a3
callq 0x9411
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x8c55
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: kscrollup
void
kscrollup(const Arg* a)
{
  int n = a->i;

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

  if ((term.histi - term.scr - n) > 0  && (unsigned int)term.scr <= (histsize-n)) {
    term.scr += n;
    selscroll(0, n);
    tfulldirt();
  }
}

// Assembly:
movl (%rdi), %eax
movl %eax, %esi
sarl $0x1f, %esi
andl 0x158cd(%rip), %esi     # 0x1e698
addl %eax, %esi
movl 0x158e5(%rip), %edx     # 0x1e6b8
movl 0x158e3(%rip), %ecx     # 0x1e6bc
leal (%rcx,%rsi), %eax
subl %eax, %edx
testl %edx, %edx
jle 0x8f25
pushq %rbx
leaq 0x14792(%rip), %rdx     # 0x1d580
movl (%rdx), %edx
subl %esi, %edx
cmpl %edx, %ecx
ja 0x8f24
movl %eax, 0x158bc(%rip)     # 0x1e6bc
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x8cfe
movb $0x0, 0x15840(%rip)     # 0x1e650
movl 0x15882(%rip), %eax     # 0x1e698
decl %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
movq 0x1589a(%rip), %rdx     # 0x1e6c0
movslq %ecx, %rcx
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
leaq 0x4(%rsi), %rax
andq $-0x4, %rax
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rcx,4), %rcx
addq $0xc, %rcx
movdqa 0x91ce(%rip), %xmm1     # 0x12020
movdqa 0x91d6(%rip), %xmm2     # 0x12030
movdqa 0x91de(%rip), %xmm3     # 0x12040
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rbx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0x8eb4
movl $0x1, -0xc(%rcx,%rbx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x8eca
movl $0x1, -0x8(%rcx,%rbx,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edx
testb $0x1, %dl
je 0x8f06
movl $0x1, -0x4(%rcx,%rbx,4)
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x8f17
movl $0x1, (%rcx,%rbx,4)
addq $0x4, %rbx
cmpq %rbx, %rax
jne 0x8e6a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: iso14755
void
iso14755(const Arg *arg)
{
  FILE *p;
  char *us, *e, codepoint[9], uc[UTF_SIZ];
  unsigned long utf32;

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x95ab(%rip), %rdi      # 0x126ed
leaq 0xe3b3(%rip), %rsi      # 0x174fc
callq 0x69b0
testq %rax, %rax
je 0x91db
movq %rax, %r14
leaq 0xf(%rsp), %rdi
movl $0x9, %esi
movq %rax, %rdx
callq 0x62f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x63c0
testq %rbx, %rbx
je 0x91db
movzbl (%rbx), %eax
testl %eax, %eax
je 0x91db
cmpl $0x2d, %eax
je 0x91db
movq %rbx, %rdi
callq 0x63b0
cmpq $0x7, %rax
ja 0x91db
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x69c0
cmpq $-0x1, %rax
je 0x91db
movq (%rsp), %rcx
movzbl (%rcx), %ecx
cmpl $0xa, %ecx
je 0x91bc
testl %ecx, %ecx
jne 0x91db
leaq 0xb(%rsp), %rbx
movl %eax, %edi
movq %rbx, %rsi
callq 0x723d
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x8138
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: tmoveto
void
tmoveto(int x, int y)
{
  int miny, maxy;

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

// Assembly:
movb 0x154a2(%rip), %dl      # 0x1e6e0
movl 0x154a8(%rip), %eax     # 0x1e6ec
movl 0x154a6(%rip), %ecx     # 0x1e6f0
movl 0x15447(%rip), %r8d     # 0x1e698
movl %edx, %r9d
andb $-0x2, %r9b
movb %r9b, 0x15481(%rip)     # 0x1e6e0
xorl %r9d, %r9d
movl $0x0, %r10d
testl %edi, %edi
js 0x927d
movl 0x15429(%rip), %r10d    # 0x1e69c
decl %r10d
cmpl %edi, %r10d
cmovgel %edi, %r10d
decl %r8d
testb $0x2, %dl
cmovel %r8d, %ecx
cmovel %r9d, %eax
movl %r10d, 0x15446(%rip)    # 0x1e6d8
cmpl %esi, %ecx
cmovgel %esi, %ecx
cmpl %esi, %eax
cmovgl %eax, %ecx
movl %ecx, 0x1543a(%rip)     # 0x1e6dc
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: tswapscreen
void
tswapscreen(void)
{
  Line *tmp = term.line;

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

// Assembly:
movdqu 0x15287(%rip), %xmm0    # 0x1e6a0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x1527a(%rip)    # 0x1e6a0
xorb $0x4, 0x152c7(%rip)     # 0x1e6f4
movb $0x0, 0x1521c(%rip)     # 0x1e650
movl 0x1525e(%rip), %eax     # 0x1e698
decl %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
movq 0x15276(%rip), %rdx     # 0x1e6c0
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movslq %ecx, %rcx
leaq 0x4(%rsi), %rax
andq $-0x4, %rax
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%rdx,%rcx,4), %rcx
addq $0xc, %rcx
xorl %edx, %edx
movdqa 0x8ba8(%rip), %xmm1     # 0x12020
movdqa 0x8bb0(%rip), %xmm2     # 0x12030
movdqa 0x8bb8(%rip), %xmm3     # 0x12040
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x94db
movl $0x1, -0xc(%rcx,%rdx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x94f2
movl $0x1, -0x8(%rcx,%rdx,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x952f
movl $0x1, -0x4(%rcx,%rdx,4)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x9541
movl $0x1, (%rcx,%rdx,4)
addq $0x4, %rdx
cmpq %rdx, %rax
jne 0x9490
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: tdumpline
void
tdumpline(int n)
{
  char buf[UTF_SIZ];
  Glyph *bp, *end;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x149ac(%rip), %rax     # 0x1e6a0
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x7987
movl 0x14996(%rip), %ecx     # 0x1e69c
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r15
addq $-0x10, %r15
cmpq %r15, %r14
je 0x9d23
jbe 0x9d29
jmp 0x9d4d
cmpl $0x20, (%r14)
je 0x9d4d
leaq 0xc(%rsp), %rbx
movl (%r14), %edi
movq %rbx, %rsi
callq 0x723d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9c8d
addq $0x10, %r14
cmpq %r15, %r14
jbe 0x9d2e
leaq 0x8953(%rip), %rdi      # 0x126a7
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9c8d
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/st.c
// Function: tstrsequence
void
tstrsequence(uchar c)
{
  strreset();

  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
leaq 0x14fd8(%rip), %rdi     # 0x20738
movl $0xa8, %edx
xorl %esi, %esi
callq 0x60c0
movl $0x200, %esi            # imm = 0x200
xorl %edi, %edi
callq 0x71e9
cmpl $0x9d, %ebx
jg 0xb794
cmpl $0x90, %ebx
je 0xb7a8
cmpl $0x9d, %ebx
jne 0xb7ae
movb $0x5d, %bl
jmp 0xb7ae
cmpl $0x9e, %ebx
je 0xb7ac
cmpl $0x9f, %ebx
jne 0xb7ae
movb $0x5f, %bl
jmp 0xb7ae
movb $0x50, %bl
jmp 0xb7ae
movb $0x5e, %bl
leaq 0x14f83(%rip), %rdi     # 0x20738
movl $0xa8, %edx
xorl %esi, %esi
callq 0x60c0
movl $0x200, %esi            # imm = 0x200
xorl %edi, %edi
callq 0x71e9
movq $0x0, 0x14f60(%rip) # 0x20738
movq %rax, 0x14f61(%rip)     # 0x20740
movq $0x200, 0x14f5e(%rip) # imm = 0x200
leaq 0x14f5f(%rip), %rdi     # 0x20750
movl $0x90, %edx
xorl %esi, %esi
callq 0x60c0
movb %bl, 0x14f35(%rip)      # 0x20738
orb $0x4, 0x12eee(%rip)     # 0x1e6f8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0xc67c
testl %eax, %eax
jne 0xb9b5
testl %ebx, %ebx
leaq 0xbf32(%rip), %rax      # 0x1787e
leaq 0xb473(%rip), %rcx      # 0x16dc6
cmoveq %rax, %rcx
movzbl 0xf(%rsp), %r9d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
subq $0x8, %rsp
leaq 0x6fcb(%rip), %rdx      # 0x1293f
leaq 0x18(%rsp), %rdi
movl $0x20, %esi
movl %ebp, %r8d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
pushq %r9
callq 0x60d0
addq $0x30, %rsp
cmpl $0x20, %eax
jae 0xb9e6
movl %eax, %esi
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x8138
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
movq 0x11632(%rip), %rax     # 0x1cff0
movq (%rax), %rdi
leaq 0x6f73(%rip), %rax      # 0x1293b
leaq 0x6f67(%rip), %rdx      # 0x12936
cmoveq %rax, %rdx
leaq 0x6f37(%rip), %rsi      # 0x12911
movl %r14d, %ecx
xorl %eax, %eax
callq 0x6970
jmp 0xb9ac
xorl %esi, %esi
testl %ebx, %ebx
sete %sil
movl %eax, %edi
callq 0x6e39
jmp 0xb9ac
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0x12c85(%rip), %rbx     # 0x1e6d8
movl 0x12c43(%rip), %eax     # 0x1e69c
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 0x12c28(%rip), %rdx     # 0x1e6a0
movslq 0x12c5d(%rip), %rsi     # 0x1e6dc
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 0x6580
movl 0x12c33(%rip), %ecx     # 0x1e6dc
leal (%rbx,%r14), %edx
decl %edx
movl %ebx, %edi
movl %ecx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a3
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0xbae2
movl 0x12c1d(%rip), %r14d    # 0x1e6f0
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xbae5
xorl %r14d, %r14d
movslq %ebx, %r15
testl %edx, %edx
je 0xbb26
movl 0x12bc6(%rip), %eax     # 0x1e6b8
incl %eax
leaq 0x11a85(%rip), %rcx     # 0x1d580
xorl %edx, %edx
divl (%rcx)
movl %edx, 0x12bb3(%rip)     # 0x1e6b8
movq 0x12ba4(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x12b86(%rip), %rsi     # 0x1e6a0
movq (%rsi,%r15,8), %rdi
movq %rdi, (%rax,%rcx,8)
movq %rdx, (%rsi,%r15,8)
movl 0x12b70(%rip), %edx     # 0x1e69c
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x92a3
movl 0x12ba9(%rip), %esi     # 0x1e6f0
movl %ebp, %edi
callq 0x74a4
movl 0x12b9c(%rip), %eax     # 0x1e6f0
subl %r14d, %eax
subl %ebx, %eax
jl 0xbb8b
movslq %r14d, %rcx
movq 0x12b3b(%rip), %rdx     # 0x1e6a0
addq %r15, %rcx
leaq (%rdx,%rcx,8), %rcx
leaq (%rdx,%r15,8), %rdx
incl %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
movq %rdi, (%rcx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0xbb74
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8cfe
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0x12b3f(%rip), %rsi     # 0x1e6f0
testl %eax, %eax
js 0xbbc7
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0xbbca
xorl %r14d, %r14d
testl %edx, %edx
je 0xbc0c
movl 0x12ae4(%rip), %eax     # 0x1e6b8
leaq 0x119a5(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x12acd(%rip)     # 0x1e6b8
movq 0x12abe(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x12aa0(%rip), %rdi     # 0x1e6a0
movq (%rdi,%rsi,8), %r8
movq %r8, (%rax,%rcx,8)
movq %rdx, (%rdi,%rsi,8)
subl %r14d, %esi
movl %ebx, %edi
callq 0x74a4
movl 0x12ad4(%rip), %ecx     # 0x1e6f0
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0x12a73(%rip), %edx     # 0x1e69c
decl %edx
xorl %edi, %edi
callq 0x92a3
movslq 0x12ab7(%rip), %rax     # 0x1e6f0
leal (%r14,%rbx), %ecx
cmpl %ecx, %eax
jl 0xbc77
movslq %r14d, %rdi
movslq %ecx, %rcx
movq 0x12a52(%rip), %rdx     # 0x1e6a0
incq %rax
shlq $0x3, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
movq -0x8(%rdx,%rax,8), %rdi
movq -0x8(%rsi,%rax,8), %r8
movq %r8, -0x8(%rdx,%rax,8)
movq %rdi, -0x8(%rsi,%rax,8)
decq %rax
cmpq %rcx, %rax
jg 0xbc5b
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8cfe
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0x12695(%rip), %rdi     # 0x1e6d8
movl 0x12653(%rip), %ecx     # 0x1e69c
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 0x1263b(%rip), %rdx     # 0x1e6a0
movslq 0x12670(%rip), %rsi     # 0x1e6dc
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 0x6580
movl 0x12609(%rip), %edx     # 0x1e69c
movl %edx, %edi
subl %ebx, %edi
movl 0x1263f(%rip), %ecx     # 0x1e6dc
decl %edx
movl %ecx, %esi
popq %rbx
jmp 0x92a3
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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();

  xclipcopy();
}

// Assembly:
testq %rdi, %rdi
je 0xc402
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x14a40(%rip), %rdi     # 0x20df0
callq 0x6380
movq %r14, 0x14a34(%rip)     # 0x20df0
movq 0x14805(%rip), %rdi     # 0x20bc8
movq 0x1480e(%rip), %rdx     # 0x20bd8
movl $0x1, %esi
movq %rbx, %rcx
callq 0x66a0
movq 0x147ea(%rip), %rdi     # 0x20bc8
movl $0x1, %esi
callq 0x69e0
cmpq 0x147e9(%rip), %rax     # 0x20bd8
je 0xc3f6
callq 0x7379
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc336
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 (USE_ARGB) {
    currentAlpha = is_focused ? alpha : alpha_unfocused;
    dc.col[defaultbg].color.alpha = (0xffff * currentAlpha) / OPAQUE;
    dc.col[defaultbg].pixel &= 0x00111111;
    dc.col[defaultbg].pixel |= currentAlpha << 24;
  }
  loaded = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x146b9(%rip)     # 0x20acc
jne 0xc465
movq 0x146bc(%rip), %rax     # 0x20ad8
testq %rax, %rax
jle 0xc488
movq 0x146a8(%rip), %rbx     # 0x20ad0
movq 0x14799(%rip), %rdi     # 0x20bc8
movq 0x1483a(%rip), %rsi     # 0x20c70
movq 0x14793(%rip), %rdx     # 0x20bd0
movq %rbx, %rcx
callq 0x6660
addq $0x10, %rbx
movq 0x14688(%rip), %rax     # 0x20ad8
movq %rax, %rcx
shlq $0x4, %rcx
addq 0x14672(%rip), %rcx     # 0x20ad0
cmpq %rcx, %rbx
jb 0xc428
jmp 0xc488
movq $0x106, 0x14668(%rip) # imm = 0x106
movl $0x1060, %edi           # imm = 0x1060
callq 0x7125
movq %rax, 0x1464f(%rip)     # 0x20ad0
movq 0x14650(%rip), %rax     # 0x20ad8
testq %rax, %rax
je 0xc4f6
leaq 0x1113c(%rip), %r12     # 0x1d5d0
leaq 0xaa8e(%rip), %rbx      # 0x16f29
leaq 0xaa68(%rip), %r14      # 0x16f0a
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x14621(%rip), %rdx     # 0x20ad0
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xc571
testl %eax, %eax
jne 0xc4e2
movq (%r12), %rsi
testq %rsi, %rsi
je 0xc4d5
movq %r14, %rdi
xorl %eax, %eax
callq 0x714f
jmp 0xc4e2
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x714f
incq %r15
addq $0x8, %r12
addq $0x10, %r13
cmpq %r15, 0x145e4(%rip)     # 0x20ad8
ja 0xc4a8
movl 0x110a8(%rip), %eax     # 0x1d5a4
cmpl $0xff, %eax
je 0xc560
cmpq $0x0, 0x147f5(%rip)     # 0x20d00
jne 0xc560
cmpb $0x0, 0x147f4(%rip)     # 0x20d08
je 0xc51c
movl 0x1108c(%rip), %eax     # 0x1d5a8
movl %eax, 0x147ea(%rip)     # 0x20d0c
movl %eax, %ecx
shll $0x10, %ecx
subl %eax, %ecx
movl $0x80808081, %edx       # imm = 0x80808081
imulq %rcx, %rdx
shrq $0x27, %rdx
movq 0x14593(%rip), %rcx     # 0x20ad0
movl 0x11069(%rip), %esi     # 0x1d5ac
shlq $0x4, %rsi
movw %dx, 0xe(%rcx,%rsi)
movq (%rcx,%rsi), %rdx
andl $0x111111, %edx         # imm = 0x111111
shll $0x18, %eax
orq %rdx, %rax
movq %rax, (%rcx,%rsi)
movb $0x1, 0x14565(%rip)     # 0x20acc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xtermclear
void
xtermclear(int col1, int row1, int col2, int row2)
{
  XftDrawRect(xw.draw,
      &dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg],
      win.dynborder_w + col1 * win.cw,
      win.dynborder_h + row1 * win.ch,
      (col2-col1+1) * win.cw,
      (row2-row1+1) * win.ch);
}

// Assembly:
movl %edi, %r9d
movq 0x14525(%rip), %rdi     # 0x20c68
testb $0x20, 0x145ea(%rip)    # 0x20d34
leaq 0x10e5f(%rip), %rax     # 0x1d5b0
leaq 0x10e54(%rip), %r8      # 0x1d5ac
cmovneq %rax, %r8
movl (%r8), %eax
shlq $0x4, %rax
addq 0x14366(%rip), %rax     # 0x20ad0
movl 0x145bb(%rip), %r10d    # 0x20d2c
subl %r9d, %edx
leal 0x1(%rdx), %r8d
imull %r10d, %r8d
movl %r10d, %edx
imull %r9d, %edx
addl 0x1459b(%rip), %edx     # 0x20d24
movl 0x14598(%rip), %r10d    # 0x20d28
subl %esi, %ecx
leal 0x1(%rcx), %r9d
imull %r10d, %r9d
movl %r10d, %ecx
imull %esi, %ecx
addl 0x1457a(%rip), %ecx     # 0x20d20
movq %rax, %rsi
jmp 0x6420
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: deepcopy
char *
deepcopy(char *src) {
  char *tmpBuf = NULL;
  int srcLen = (strlen(src) + 1) * sizeof(char);

  // deep string copy
  tmpBuf = (char *)malloc(srcLen);
  bzero(tmpBuf, srcLen);
  strncpy(tmpBuf, src, srcLen - 1);

#ifdef __DEBUG
  printf("deepcopy(): duped string 0x%X to 0x%X\n", src, tmpBuf);
  printf("deepcopy(): source string: [%s], dest string [%s]\n", src, tmpBuf);
#endif

  // return copied string
  return tmpBuf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x63b0
movq %rax, %r14
incl %eax
movslq %eax, %rsi
movl $0x1, %edi
callq 0x67e0
movslq %r14d, %rdx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6830
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: allocateFontInfo
struct _spareFontInfo *
allocateFontInfo(char *content)
{
  struct _spareFontInfo *newItem = NULL;
  newItem = (struct _spareFontInfo *)malloc(sizeof(struct _spareFontInfo));

  if (newItem != NULL) {
    newItem->fontStringLen = strlen(content);
    newItem->fontString = deepcopy(content);
    newItem->next = NULL;
  }

#ifdef __DEBUG
  printf("allocateFontInfo(): newItem 0x%X, content [%s]\n", newItem, newItem->fontString);
#endif

  return newItem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x6220
movq %rax, %rbx
testq %rax, %rax
je 0xc818
movq %r14, %rdi
callq 0x63b0
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0xc7ae
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: loadSpareFontList
spareFontList *
loadSpareFontList(char *spec)
{
  spareFontList *tempList = NULL;
  char needle = ',';
  char *loopPtr = NULL, *stringToParse = NULL;
  struct _spareFontInfo *fontItem = NULL;

  if (!spec) return NULL;

  // allocate fontlist object
  tempList = (spareFontList *)malloc(sizeof(spareFontList));
  tempList->fonts = NULL;

  // count spare fonts defined in Xresources template
  // spec must be not NULL, assume at least one font is correctly specified
  for (tempList->fontCount=1, loopPtr = strchr(spec, needle); loopPtr != NULL; loopPtr = strchr(loopPtr+1, needle), tempList->fontCount++);

  // parse font string spec
  stringToParse = deepcopy(spec);
  if (stringToParse == NULL) {
    unloadSpareFontList(tempList);
    return NULL;
  }

  // parse font spec into a linked list
  loopPtr = strtok(stringToParse, &needle);
  while (loopPtr != NULL) {
    fontItem = (struct _spareFontInfo *)allocateFontInfo(loopPtr);
#ifdef __DEBUG
    printf("loadSpareFontList(): fontItem 0x%X, tempList->fonts 0x%X\n", fontItem, tempList->fonts);
#endif
    if (tempList->fonts == NULL) {
      tempList->fonts = fontItem;
    }
    else {
      lastItem(tempList->fonts)->next = fontItem;
    }
#ifdef __DEBUG
    printf("loadSpareFontList(): lastItem 0x%X\n", lastItem(tempList->fonts));
#endif
    loopPtr = strtok(NULL, &needle);
  }

  // return fontList
#ifdef __DEBUG
  printSpareFontInfo(tempList->fonts);
#endif
  return tempList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x2c, 0x7(%rsp)
testq %rdi, %rdi
je 0xc952
movq %rdi, %r14
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movl $0x1, (%rax)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6590
testq %rax, %rax
je 0xc8e2
movl $0x2, %ebp
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x6590
movl %ebp, (%rbx)
incl %ebp
testq %rax, %rax
jne 0xc8c9
movq %r14, %rdi
callq 0xc7ae
testq %rax, %rax
je 0xc943
leaq 0x7(%rsp), %rsi
movq %rax, %rdi
callq 0x6760
testq %rax, %rax
je 0xc954
xorl %r15d, %r15d
leaq 0x7(%rsp), %r14
movq %rax, %rdi
callq 0xc7e1
testq %r15, %r15
je 0xc92b
movq %r15, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0xc919
movq %rax, 0x10(%rcx)
jmp 0xc92e
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x6760
testq %rax, %rax
jne 0xc909
movq %r15, 0x8(%rbx)
jmp 0xc954
xorl %edi, %edi
callq 0xc835
movq %rbx, %rdi
callq 0x6380
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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;
  XSetWMName(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 0x14085(%rip), %rax     # 0x20d40
cmoveq %rax, %rdi
cmpb $0x0, (%rdi)
cmoveq %rax, %rdi
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x13ef3(%rip), %rdi     # 0x20bc8
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6480
testl %eax, %eax
jne 0xcd2d
movq 0x13ed4(%rip), %rdi     # 0x20bc8
movq 0x13edd(%rip), %rsi     # 0x20bd8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x13eb9(%rip), %rdi     # 0x20bc8
movq 0x13ec2(%rip), %rsi     # 0x20bd8
movq 0x13eeb(%rip), %rcx     # 0x20c08
movq %rbx, %rdx
callq 0x64a0
movq (%rbx), %rdi
callq 0x60a0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p, int pop)
{
  XTextProperty prop;

  free(titlestack[tstki]);
  if (pop) {
    titlestack[tstki] = NULL;
    tstki = (tstki - 1 + TITLESTACKSIZE) % TITLESTACKSIZE;
    p = titlestack[tstki] ? titlestack[tstki] : opt_title;
  } else if (p) {
    titlestack[tstki] = xstrdup(p);
  } else {
    titlestack[tstki] = NULL;
    p = opt_title;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, (%rsp)
movl 0x14013(%rip), %r15d    # 0x20d90
leaq 0x13fcc(%rip), %r14     # 0x20d50
movq (%r14,%r15,8), %rdi
callq 0x6380
testl %ebp, %ebp
je 0xcdb1
movq $0x0, (%r14,%r15,8)
leal -0x1(%r15), %eax
andl $0x7, %eax
movl %eax, 0x13fea(%rip)     # 0x20d90
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xcdd2
jmp 0xcdd9
testq %rbx, %rbx
je 0xcdca
movq %rbx, %rdi
callq 0x7213
movl 0x13fcc(%rip), %ecx     # 0x20d90
movq %rax, (%r14,%rcx,8)
jmp 0xcddd
movq $0x0, (%r14,%r15,8)
movq 0x13f67(%rip), %rax     # 0x20d40
movq %rax, (%rsp)
movq 0x13de4(%rip), %rdi     # 0x20bc8
movq %rsp, %rsi
leaq 0x8(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6480
testl %eax, %eax
jne 0xce3f
movq 0x13dc2(%rip), %rdi     # 0x20bc8
movq 0x13dcb(%rip), %rsi     # 0x20bd8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x13da7(%rip), %rdi     # 0x20bc8
movq 0x13db0(%rip), %rsi     # 0x20bd8
movq 0x13dd1(%rip), %rcx     # 0x20c00
movq %rbx, %rdx
callq 0x64a0
movq (%rbx), %rdi
callq 0x60a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xpushtitle
void
xpushtitle(void)
{
  int tstkin = (tstki + 1) % TITLESTACKSIZE;

  free(titlestack[tstkin]);
  titlestack[tstkin] = titlestack[tstki] ? xstrdup(titlestack[tstki]) : NULL;
  tstki = tstkin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x13f3a(%rip), %r15d    # 0x20d90
leal 0x1(%r15), %ebx
andl $0x7, %ebx
leaq 0x13eec(%rip), %r14     # 0x20d50
movq (%r14,%rbx,8), %rdi
callq 0x6380
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xce7d
callq 0x7213
jmp 0xce7f
xorl %eax, %eax
movq %rax, (%r14,%rbx,8)
movl %ebx, 0x13f07(%rip)     # 0x20d90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
  if (xw.ime.xic == NULL)
    return;

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

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

// Assembly:
movl %edi, %eax
movq 0x13089(%rip), %rdi     # 0x20c50
testq %rdi, %rdi
je 0xdc0d
imull 0x13159(%rip), %eax     # 0x20d2c
addl 0x1314b(%rip), %eax     # 0x20d24
movw %ax, 0x13078(%rip)      # 0x20c58
incl %esi
imull 0x1313f(%rip), %esi     # 0x20d28
addl 0x13131(%rip), %esi     # 0x20d20
movw %si, 0x13064(%rip)      # 0x20c5a
movq 0x13063(%rip), %rdx     # 0x20c60
leaq 0x9342(%rip), %rsi      # 0x16f46
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x62a0
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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, 0x130a8(%rip)     # 0x20d34
jne 0xdc9d
pushq %rax
movl $0x1, %edi
callq 0xdcbd
addq $0x8, %rsp
movl 0x12e25(%rip), %edx     # 0x20ac8
testl %edx, %edx
je 0xdcbc
movq 0x12f1a(%rip), %rdi     # 0x20bc8
movq 0x12f23(%rip), %rsi     # 0x20bd8
xorl %ecx, %ecx
jmp 0x69a0
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0x12ef7(%rip), %rdi     # 0x20bc8
movq 0x12f00(%rip), %rsi     # 0x20bd8
callq 0x6550
movq %rax, %rbx
movq $-0x101, %rax           # imm = 0xFEFF
andq (%rbx), %rax
shll $0x8, %r14d
orq %rax, %r14
movq %r14, (%rbx)
movq 0x12ecd(%rip), %rdi     # 0x20bc8
movq 0x12ed6(%rip), %rsi     # 0x20bd8
movq %rbx, %rdx
callq 0x6a10
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x60a0
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: resource_load
int
resource_load(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 0x13058(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x9214(%rip), %rcx      # 0x16f5e
cmovneq %rax, %rcx
leaq 0x9203(%rip), %r13      # 0x16f58
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 0x60d0
movq 0x13025(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x91dc(%rip), %rcx      # 0x16f61
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 0x60d0
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 0x68f0
movq 0x8(%r15), %r15
movl $0x1, %r14d
testq %r15, %r15
je 0xddf6
movq 0x18(%rsp), %rsi
leaq 0x917c(%rip), %rdi      # 0x16f64
movl $0x40, %edx
callq 0x6210
testl %eax, %eax
je 0xde0b
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 0xde42
cmpl $0x1, %eax
je 0xde2a
testl %eax, %eax
jne 0xddf6
movq 0x8(%rsp), %rax
movq %r15, (%rax)
jmp 0xddf6
movq %r15, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x69c0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
jmp 0xddf6
movq %r15, %rdi
xorl %esi, %esi
callq 0x64c0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xddf6
// File: /workspace/github_c_makefile_star2_O3/mcaimi[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 0x65c0
movq 0x12d60(%rip), %rdi     # 0x20bc8
callq 0x61a0
testq %rax, %rax
je 0xdeaf
movq %rax, %rdi
callq 0x6720
movq %rax, %rbx
movq $-0x18, %r14
leaq 0xffb5(%rip), %r15      # 0x1de40
movq 0x18(%r14,%r15), %rsi
movl 0x20(%r14,%r15), %edx
movq 0x28(%r14,%r15), %rcx
movq %rbx, %rdi
callq 0xdd19
addq $0x18, %r14
cmpq $0x4b0, %r14            # imm = 0x4B0
jb 0xde8b
popq %rbx
popq %r14
popq %r15
retq