LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, 0x16e7c(%rip)     # 0x1e720
je 0x78ad
pushq $0x1
popq %rbx
xorl %esi, %esi
jmp 0x78f1
movl 0x16e65(%rip), %edi     # 0x1e718
movslq 0x18e76(%rip), %rax     # 0x20730
leaq 0x16e6f(%rip), %rsi     # 0x1e730
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6200
cmpl $-0x1, %eax
je 0x795a
testl %eax, %eax
je 0x7977
xorl %esi, %esi
cmpb $0x0, 0x16e35(%rip)     # 0x1e720
cmovel %eax, %esi
movslq %eax, %rbx
addl 0x18e39(%rip), %esi     # 0x20730
movl %esi, 0x18e33(%rip)     # 0x20730
leaq 0x16e2c(%rip), %r14     # 0x1e730
movq %r14, %rdi
xorl %edx, %edx
callq 0x7994
movl 0x18e1c(%rip), %ecx     # 0x20730
subl %eax, %ecx
movl %ecx, 0x18e14(%rip)     # 0x20730
jle 0x792e
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x6580
movl 0x16d88(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x794f
leaq 0x15c41(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
decl %ecx
cmpl %ecx, %eax
jae 0x794f
incl %eax
movl %eax, 0x16d6d(%rip)     # 0x1e6bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6620
movl (%rax), %edi
callq 0x64b0
leaq 0x9ceb(%rip), %rdi      # 0x11658
movq %rax, %rsi
xorl %eax, %eax
callq 0x6c0a
movq 0x15672(%rip), %rax     # 0x1cff0
movq (%rax), %rsi
leaq 0x9cbc(%rip), %rdi      # 0x11644
callq 0x6500
xorl %edi, %edi
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O2/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 0x16b4c(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x7ba0
pushq %rax
movl (%rdi), %ecx
movl %ecx, %esi
sarl $0x1f, %esi
andl 0x16b16(%rip), %esi     # 0x1e698
addl %ecx, %esi
cmpl %eax, %esi
cmovgel %eax, %esi
subl %esi, %eax
movl %eax, 0x16b2b(%rip)     # 0x1e6bc
negl %esi
xorl %edi, %edi
callq 0x8430
popq %rax
jmp 0x84d5
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq 0x16961(%rip), %xmm0    # 0x1e698
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
leaq 0x8(%rsp), %rdx
movd %xmm0, (%rdx)
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
movl 0x169c5(%rip), %edi     # 0x1e718
movl $0x5414, %esi           # imm = 0x5414
xorl %eax, %eax
callq 0x6120
testl %eax, %eax
js 0x7d69
addq $0x10, %rsp
popq %rbx
retq
movq 0x15280(%rip), %rax     # 0x1cff0
movq (%rax), %rbx
callq 0x6620
movl (%rax), %edi
callq 0x64b0
leaq 0x98f3(%rip), %rsi      # 0x11679
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6970
jmp 0x7d63
// File: /workspace/github_c_makefile_star2_O2/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 0x15727(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x1571a(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x1680a(%rip)    # 0x1e6a8
movups %xmm0, 0x167f3(%rip)    # 0x1e698
andq $0x0, 0x1681b(%rip)     # 0x1e6c8
movups %xmm0, 0x16804(%rip)    # 0x1e6b8
movl %eax, 0x16816(%rip)     # 0x1e6d0
movl %ecx, 0x16814(%rip)     # 0x1e6d4
movups %xmm0, 0x16811(%rip)    # 0x1e6d8
movups %xmm0, 0x1681a(%rip)    # 0x1e6e8
movups %xmm0, 0x16823(%rip)    # 0x1e6f8
movups %xmm0, 0x1682c(%rip)    # 0x1e708
movq 0x167cd(%rip), %rdi     # 0x1e6b0
leaq 0x15696(%rip), %r14     # 0x1d580
movl (%r14), %esi
incl %esi
shlq $0x3, %rsi
callq 0x6ca2
movq %rax, 0x167b1(%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 0x7f24
popq %rbx
popq %r14
popq %rbp
jmp 0x8321
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x15284(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x15277(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
andl $0x0, 0x1638a(%rip)     # 0x1e6c8
andw $0x0, 0x16386(%rip)     # 0x1e6cc
movl %eax, 0x16384(%rip)     # 0x1e6d0
movl %ecx, 0x16382(%rip)     # 0x1e6d4
andq $0x0, 0x1637e(%rip)     # 0x1e6d8
movb $0x0, 0x1637f(%rip)     # 0x1e6e0
movq 0x163a0(%rip), %rbx     # 0x1e708
movslq 0x1632d(%rip), %rdx     # 0x1e69c
shlq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60c0
leaq 0x1521c(%rip), %rax     # 0x1d5a0
movl (%rax), %ecx
movl 0x16310(%rip), %edx     # 0x1e69c
cmpl %edx, %ecx
jae 0x839d
movl %ecx, %esi
movl $0x1, (%rbx,%rsi,4)
addl (%rax), %ecx
jmp 0x838c
andl $0x0, 0x16348(%rip)     # 0x1e6ec
movl 0x162ee(%rip), %eax     # 0x1e698
decl %eax
movl %eax, 0x1633e(%rip)     # 0x1e6f0
movl $0x41, 0x16338(%rip)    # 0x1e6f4
movq $0x3030303, 0x16335(%rip) # imm = 0x3030303
pushq $0x2
popq %rbx
leaq 0x1866f(%rip), %r14     # 0x20a40
subl $0x1, %ebx
jb 0x8428
xorl %edi, %edi
xorl %esi, %esi
callq 0x8898
movl 0x1630f(%rip), %eax     # 0x1e6f4
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rax
movups 0x162de(%rip), %xmm0    # 0x1e6d4
movups %xmm0, 0xc(%rax,%r14)
movups 0x162c5(%rip), %xmm0    # 0x1e6c8
movups %xmm0, (%rax,%r14)
movl 0x1628e(%rip), %edx     # 0x1e69c
decl %edx
movl 0x16282(%rip), %ecx     # 0x1e698
decl %ecx
xorl %edi, %edi
xorl %esi, %esi
callq 0x8903
callq 0x8a28
jmp 0x83d1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x161a0(%rip), %esi     # 0x1e698
addl %eax, %esi
movl 0x161b8(%rip), %edx     # 0x1e6b8
movl 0x161b6(%rip), %ecx     # 0x1e6bc
leal (%rcx,%rsi), %eax
subl %eax, %edx
testl %edx, %edx
jle 0x851e
leaq 0x1506a(%rip), %rdx     # 0x1d580
movl (%rdx), %edx
subl %esi, %edx
cmpl %edx, %ecx
jbe 0x851f
retq
pushq %rax
movl %eax, 0x16196(%rip)     # 0x1e6bc
xorl %edi, %edi
callq 0x8430
popq %rax
jmp 0x84d5
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/st.c
// Function: xwrite
ssize_t
xwrite(int fd, const char *s, size_t len)
{
  size_t aux = len;
  ssize_t r;

  while (len > 0) {
    r = write(fd, s, len);
    if (r < 0)
      return r;
    len -= r;
    s += r;
  }

  return aux;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, %r15
testq %r15, %r15
je 0x8755
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6990
testq %rax, %rax
js 0x8752
subq %rax, %r15
addq %rax, %r14
jmp 0x8733
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8f4c(%rip), %rdi      # 0x116bd
leaq 0xdd54(%rip), %rsi      # 0x164cc
callq 0x69b0
testq %rax, %rax
je 0x8800
movq %rax, %r14
leaq 0xf(%rsp), %rdi
pushq $0x9
popq %rsi
movq %rax, %rdx
callq 0x62f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x63c0
testq %rbx, %rbx
je 0x8800
movzbl (%rbx), %eax
testl %eax, %eax
je 0x8800
cmpl $0x2d, %eax
je 0x8800
movq %rbx, %rdi
callq 0x63b0
cmpq $0x7, %rax
ja 0x8800
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x69c0
cmpq $-0x1, %rax
je 0x8800
movq (%rsp), %rcx
movzbl (%rcx), %ecx
cmpl $0xa, %ecx
je 0x87e3
testl %ecx, %ecx
jne 0x8800
leaq 0xb(%rsp), %rbx
movl %eax, %edi
movq %rbx, %rsi
callq 0x6cf6
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7a9b
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/st.c
// Function: tsetscroll
void
tsetscroll(int t, int b)
{
  int temp;

  LIMIT(t, 0, term.row-1);
  LIMIT(b, 0, term.row-1);
  if (t > b) {
    temp = t;
    t = b;
    b = temp;
  }
  term.top = t;
  term.bot = b;
}

// Assembly:
xorl %eax, %eax
movl $0x0, %ecx
testl %edi, %edi
js 0x8870
movl 0x15e2f(%rip), %ecx     # 0x1e698
decl %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
testl %esi, %esi
js 0x8881
movl 0x15e1e(%rip), %eax     # 0x1e698
decl %eax
cmpl %esi, %eax
cmovgel %esi, %eax
cmpl %eax, %ecx
movl %eax, %edx
cmovgl %ecx, %edx
cmovll %ecx, %eax
movl %eax, 0x15e5b(%rip)     # 0x1e6ec
movl %edx, 0x15e59(%rip)     # 0x1e6f0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15e42(%rip), %dl      # 0x1e6e0
movl 0x15e48(%rip), %eax     # 0x1e6ec
movl 0x15e46(%rip), %ecx     # 0x1e6f0
movl 0x15de7(%rip), %r8d     # 0x1e698
movl %edx, %r9d
andb $-0x2, %r9b
movb %r9b, 0x15e21(%rip)     # 0x1e6e0
xorl %r9d, %r9d
movl $0x0, %r10d
testl %edi, %edi
js 0x88dd
movl 0x15dc9(%rip), %r10d    # 0x1e69c
decl %r10d
cmpl %edi, %r10d
cmovgel %edi, %r10d
decl %r8d
testb $0x2, %dl
cmovel %r8d, %ecx
cmovel %r9d, %eax
movl %r10d, 0x15de6(%rip)    # 0x1e6d8
cmpl %esi, %ecx
cmovgel %esi, %ecx
cmpl %esi, %eax
cmovgl %eax, %ecx
movl %ecx, 0x15dda(%rip)     # 0x1e6dc
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15620(%rip), %rax     # 0x1e6a0
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x7307
movl 0x1560a(%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
jne 0x90c9
cmpl $0x20, (%r14)
jne 0x90c9
leaq 0x85bf(%rip), %rdi      # 0x11677
pushq $0x1
popq %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x902f
leaq 0xc(%rsp), %rbx
cmpq %r15, %r14
ja 0x90b1
movl (%r14), %edi
movq %rbx, %rsi
callq 0x6cf6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x902f
addq $0x10, %r14
jmp 0x90ce
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xad21
cmpl $0x9f, %ebx
je 0xabb8
cmpl $0x9d, %ebx
je 0xabb0
cmpl $0x9e, %ebx
je 0xabb4
cmpl $0x90, %ebx
jne 0xabba
movb $0x50, %bl
jmp 0xabba
movb $0x5d, %bl
jmp 0xabba
movb $0x5e, %bl
jmp 0xabba
movb $0x5f, %bl
callq 0xad21
movb %bl, 0x15b73(%rip)      # 0x20738
orb $0x4, 0x13b2c(%rip)     # 0x1e6f8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb719
testl %eax, %eax
jne 0xac6c
testl %ebx, %ebx
leaq 0xbc47(%rip), %rax      # 0x1684e
leaq 0xb188(%rip), %rcx      # 0x15d96
cmoveq %rax, %rcx
movzbl 0xf(%rsp), %r9d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
subq $0x8, %rsp
leaq 0x6ce0(%rip), %rdx      # 0x1190f
leaq 0x18(%rsp), %rdi
pushq $0x20
popq %rsi
movl %ebp, %r8d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
pushq %r9
callq 0x60d0
addq $0x30, %rsp
cmpl $0x20, %eax
jae 0xac9d
movl %eax, %esi
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x7a9b
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
movq 0x1237b(%rip), %rax     # 0x1cff0
movq (%rax), %rdi
leaq 0x6c8c(%rip), %rax      # 0x1190b
leaq 0x6c80(%rip), %rdx      # 0x11906
cmoveq %rax, %rdx
leaq 0x6c50(%rip), %rsi      # 0x118e1
movl %r14d, %ecx
xorl %eax, %eax
callq 0x6970
jmp 0xac63
testl %eax, %eax
leaq 0x6cb6(%rip), %rax      # 0x1195c
leaq 0x6cbf(%rip), %rdx      # 0x1196c
cmovsq %rax, %rdx
testl %ebx, %ebx
movq 0x12336(%rip), %rax     # 0x1cff0
movq (%rax), %rdi
leaq 0x6c47(%rip), %rax      # 0x1190b
leaq 0x6c3b(%rip), %rcx      # 0x11906
cmoveq %rax, %rcx
leaq 0x6c60(%rip), %rsi      # 0x11936
xorl %eax, %eax
callq 0x6970
jmp 0xac63
// File: /workspace/github_c_makefile_star2_O2/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 0xae7f
movl 0x13880(%rip), %r14d    # 0x1e6f0
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xae82
xorl %r14d, %r14d
testl %edx, %edx
je 0xaec5
movl 0x1382c(%rip), %eax     # 0x1e6b8
incl %eax
leaq 0x126eb(%rip), %rcx     # 0x1d580
xorl %edx, %edx
divl (%rcx)
movl %edx, 0x13819(%rip)     # 0x1e6b8
movq 0x1380a(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x137ec(%rip), %rsi     # 0x1e6a0
movslq %ebx, %r15
movq (%rsi,%r15,8), %rdi
movq %rdi, (%rax,%rcx,8)
movq %rdx, (%rsi,%r15,8)
jmp 0xaec8
movslq %ebx, %r15
movl 0x137ce(%rip), %edx     # 0x1e69c
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x8903
movl 0x13807(%rip), %esi     # 0x1e6f0
movl %ebp, %edi
callq 0x6f6b
movslq 0x137f9(%rip), %rax     # 0x1e6f0
movslq %r14d, %rdx
subq %rdx, %rax
movq 0x1379c(%rip), %rsi     # 0x1e6a0
leaq (%rsi,%r15,8), %rcx
leaq (%rsi,%rdx,8), %rdx
cmpq %rax, %r15
jg 0xaf28
movq (%rcx), %rsi
movq (%rdx,%r15,8), %rdi
movq %rdi, (%rcx)
movq %rsi, (%rdx,%r15,8)
incq %r15
addq $0x8, %rcx
jmp 0xaf0c
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8430
// File: /workspace/github_c_makefile_star2_O2/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 0x137a2(%rip), %rsi     # 0x1e6f0
testl %eax, %eax
js 0xaf64
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0xaf67
xorl %r14d, %r14d
testl %edx, %edx
je 0xafa9
movl 0x13747(%rip), %eax     # 0x1e6b8
leaq 0x12608(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x13730(%rip)     # 0x1e6b8
movq 0x13721(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x13703(%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 0x6f6b
movl 0x13737(%rip), %ecx     # 0x1e6f0
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0x136d6(%rip), %edx     # 0x1e69c
decl %edx
xorl %edi, %edi
callq 0x8903
movslq 0x1371a(%rip), %rax     # 0x1e6f0
leal (%r14,%rbx), %ecx
movslq %ecx, %rcx
movslq %r14d, %rdi
movq 0x136b9(%rip), %rdx     # 0x1e6a0
shlq $0x3, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
cmpq %rcx, %rax
jl 0xb00b
movq (%rdx,%rax,8), %rdi
movq (%rsi,%rax,8), %r8
movq %r8, (%rdx,%rax,8)
movq %rdi, (%rsi,%rax,8)
decq %rax
jmp 0xaff1
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8430
// File: /workspace/github_c_makefile_star2_O2/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 0xb4d7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1596b(%rip), %rdi     # 0x20df0
callq 0x6380
movq %r14, 0x1595f(%rip)     # 0x20df0
movq 0x15730(%rip), %rdi     # 0x20bc8
movq 0x15739(%rip), %rdx     # 0x20bd8
pushq $0x1
popq %r14
movq %r14, %rsi
movq %rbx, %rcx
callq 0x66a0
movq 0x15713(%rip), %rdi     # 0x20bc8
movq %r14, %rsi
callq 0x69e0
cmpq 0x15714(%rip), %rax     # 0x20bd8
je 0xb4cb
callq 0x6e4a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb40c
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x155e4(%rip)     # 0x20acc
jne 0xb531
movq 0x155df(%rip), %rax     # 0x20ad0
movq %rax, %rbx
movq 0x155dd(%rip), %rcx     # 0x20ad8
shlq $0x4, %rcx
addq %rax, %rcx
cmpq %rcx, %rbx
jae 0xb54d
movq 0x156ba(%rip), %rdi     # 0x20bc8
movq 0x1575b(%rip), %rsi     # 0x20c70
movq 0x156b4(%rip), %rdx     # 0x20bd0
movq %rbx, %rcx
callq 0x6660
addq $0x10, %rbx
movq 0x155a1(%rip), %rax     # 0x20ad0
jmp 0xb4f4
movq $0x106, 0x1559c(%rip) # imm = 0x106
movl $0x1060, %edi           # imm = 0x1060
callq 0x6be0
movq %rax, 0x15583(%rip)     # 0x20ad0
leaq 0x1207c(%rip), %r12     # 0x1d5d0
leaq 0xa99e(%rip), %rbx      # 0x15ef9
leaq 0xa978(%rip), %r14      # 0x15eda
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, 0x15569(%rip)     # 0x20ad8
jbe 0xb5b8
movq 0x15558(%rip), %rdx     # 0x20ad0
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xb62e
testl %eax, %eax
jne 0xb5ab
movq (%r12), %rsi
testq %rsi, %rsi
je 0xb59e
movq %r14, %rdi
xorl %eax, %eax
callq 0x6c0a
jmp 0xb5ab
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x6c0a
incq %r15
addq $0x10, %r13
addq $0x8, %r12
jmp 0xb568
movl 0x11fe6(%rip), %ecx     # 0x1d5a4
cmpl $0xff, %ecx
je 0xb61d
cmpq $0x0, 0x15732(%rip)     # 0x20d00
jne 0xb61d
cmpb $0x0, 0x15731(%rip)     # 0x20d08
je 0xb5df
movl 0x11fc9(%rip), %ecx     # 0x1d5a8
movl %ecx, 0x15727(%rip)     # 0x20d0c
imull $0xffff, %ecx, %eax     # imm = 0xFFFF
movl $0xff, %esi
xorl %edx, %edx
divl %esi
movq 0x154d5(%rip), %rdx     # 0x20ad0
movl 0x11fab(%rip), %esi     # 0x1d5ac
shlq $0x4, %rsi
movw %ax, 0xe(%rdx,%rsi)
movq (%rdx,%rsi), %rax
andl $0x111111, %eax         # imm = 0x111111
shll $0x18, %ecx
orq %rax, %rcx
movq %rcx, (%rdx,%rsi)
movb $0x1, 0x154a8(%rip)     # 0x20acc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1548c(%rip), %rdi     # 0x20c68
testb $0x20, 0x15551(%rip)    # 0x20d34
leaq 0x11dc6(%rip), %rax     # 0x1d5b0
leaq 0x11dbb(%rip), %r8      # 0x1d5ac
cmovneq %rax, %r8
movl (%r8), %eax
shlq $0x4, %rax
addq 0x152cd(%rip), %rax     # 0x20ad0
movl 0x15522(%rip), %r10d    # 0x20d2c
subl %r9d, %edx
leal 0x1(%rdx), %r8d
imull %r10d, %r8d
movl %r10d, %edx
imull %r9d, %edx
addl 0x15502(%rip), %edx     # 0x20d24
movl 0x154ff(%rip), %r10d    # 0x20d28
subl %esi, %ecx
leal 0x1(%rcx), %r9d
imull %r10d, %r9d
movl %r10d, %ecx
imull %esi, %ecx
addl 0x154e1(%rip), %ecx     # 0x20d20
movq %rax, %rsi
jmp 0x6420
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
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_O2/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
pushq $0x18
popq %rdi
callq 0x6220
movq %rax, %rbx
testq %rax, %rax
je 0xb8aa
movq %r14, %rdi
callq 0x63b0
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0xb847
movq %rax, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x2c, 0x7(%rsp)
testq %rdi, %rdi
je 0xb9d1
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x6220
movq %rax, %rbx
leaq 0x8(%rax), %r13
andq $0x0, 0x8(%rax)
movl $0x1, (%rax)
pushq $0x2c
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x6590
pushq $0x2
popq %r15
testq %rax, %rax
je 0xb96d
incq %rax
movq %rax, %rdi
movl %ebp, %esi
callq 0x6590
movl %r15d, (%rbx)
incl %r15d
jmp 0xb953
movq %r14, %rdi
callq 0xb847
testq %rax, %rax
je 0xb9c9
leaq 0x7(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x6760
xorl %r15d, %r15d
testq %rax, %rax
je 0xb9d3
movq %rax, %rdi
callq 0xb878
movq %rax, %r12
movq %r13, %rax
movq %r12, %rbp
testq %r15, %r15
je 0xb9b7
movq %r15, %rdi
callq 0xb8b5
addq $0x10, %rax
movq %r15, %rbp
movq %r12, (%rax)
xorl %edi, %edi
movq %r14, %rsi
callq 0x6760
movq %rbp, %r15
jmp 0xb98d
movq %rbx, %rdi
callq 0xb8f0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15011(%rip), %rax     # 0x20d40
cmoveq %rax, %rdi
cmpb $0x0, (%rdi)
cmoveq %rax, %rdi
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x14e7f(%rip), %rdi     # 0x20bc8
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x10(%rsp), %r8
callq 0x6480
testl %eax, %eax
jne 0xbd9d
movq 0x14e64(%rip), %rdi     # 0x20bc8
movq 0x14e6d(%rip), %rsi     # 0x20bd8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x14e49(%rip), %rdi     # 0x20bc8
movq 0x14e52(%rip), %rsi     # 0x20bd8
movq 0x14e7b(%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_O2/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 0x14fa4(%rip), %r15d    # 0x20d90
leaq 0x14f5d(%rip), %r14     # 0x20d50
movq (%r14,%r15,8), %rdi
callq 0x6380
testl %ebp, %ebp
je 0xbe1d
andq $0x0, (%r14,%r15,8)
leal -0x1(%r15), %eax
andl $0x7, %eax
movl %eax, 0x14f7e(%rip)     # 0x20d90
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xbe3b
jmp 0xbe42
testq %rbx, %rbx
je 0xbe36
movq %rbx, %rdi
callq 0x6ccc
movl 0x14f60(%rip), %ecx     # 0x20d90
movq %rax, (%r14,%rcx,8)
jmp 0xbe46
andq $0x0, (%r14,%r15,8)
movq 0x14efe(%rip), %rax     # 0x20d40
movq %rax, (%rsp)
movq 0x14d7b(%rip), %rdi     # 0x20bc8
movq %rsp, %rsi
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x8(%rsp), %r8
callq 0x6480
testl %eax, %eax
jne 0xbea4
movq 0x14d5d(%rip), %rdi     # 0x20bc8
movq 0x14d66(%rip), %rsi     # 0x20bd8
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x14d42(%rip), %rdi     # 0x20bc8
movq 0x14d4b(%rip), %rsi     # 0x20bd8
movq 0x14d6c(%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_O2/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 0x14ed5(%rip), %r15d    # 0x20d90
leal 0x1(%r15), %ebx
andl $0x7, %ebx
leaq 0x14e87(%rip), %r14     # 0x20d50
movq (%r14,%rbx,8), %rdi
callq 0x6380
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xbee2
callq 0x6ccc
jmp 0xbee4
xorl %eax, %eax
movq %rax, (%r14,%rbx,8)
movl %ebx, 0x14ea2(%rip)     # 0x20d90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14138(%rip), %rdi     # 0x20c50
testq %rdi, %rdi
je 0xcb5e
imull 0x14208(%rip), %eax     # 0x20d2c
addl 0x141fa(%rip), %eax     # 0x20d24
movw %ax, 0x14127(%rip)      # 0x20c58
incl %esi
imull 0x141ee(%rip), %esi     # 0x20d28
addl 0x141e0(%rip), %esi     # 0x20d20
movw %si, 0x14113(%rip)      # 0x20c5a
movq 0x14112(%rip), %rdx     # 0x20c60
leaq 0x93c1(%rip), %rsi      # 0x15f16
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x62a0
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x14158(%rip)     # 0x20d34
jne 0xcbeb
pushq %rax
pushq $0x1
popq %rdi
callq 0xcc0b
addq $0x8, %rsp
movl 0x13ed7(%rip), %edx     # 0x20ac8
testl %edx, %edx
je 0xcc0a
movq 0x13fcc(%rip), %rdi     # 0x20bc8
movq 0x13fd5(%rip), %rsi     # 0x20bd8
xorl %ecx, %ecx
jmp 0x69a0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13fa9(%rip), %rdi     # 0x20bc8
movq 0x13fb2(%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 0x13f7f(%rip), %rdi     # 0x20bc8
movq 0x13f88(%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_O2/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 0x1410a(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x9296(%rip), %rcx      # 0x15f2e
cmovneq %rax, %rcx
leaq 0x9285(%rip), %r13      # 0x15f28
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 0x140d7(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x925e(%rip), %rcx      # 0x15f31
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
pushq $0x1
popq %r14
testq %r15, %r15
je 0xcd40
movq 0x18(%rsp), %rsi
leaq 0x9200(%rip), %rdi      # 0x15f34
pushq $0x40
popq %rdx
callq 0x6210
testl %eax, %eax
je 0xcd55
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 0xcd8a
cmpl $0x1, %eax
je 0xcd74
testl %eax, %eax
jne 0xcd40
movq 0x8(%rsp), %rax
movq %r15, (%rax)
jmp 0xcd40
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x69c0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
jmp 0xcd40
movq %r15, %rdi
xorl %esi, %esi
callq 0x64c0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xcd40
// File: /workspace/github_c_makefile_star2_O2/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 0x13e18(%rip), %rdi     # 0x20bc8
callq 0x61a0
testq %rax, %rax
je 0xcdf4
movq %rax, %rdi
callq 0x6720
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x11071(%rip), %r15     # 0x1de40
cmpq $0x4c7, %r14            # imm = 0x4C7
ja 0xcdf4
movq (%r14,%r15), %rsi
movl 0x8(%r14,%r15), %edx
movq 0x10(%r14,%r15), %rcx
movq %rbx, %rdi
callq 0xcc67
addq $0x18, %r14
jmp 0xcdcf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: skip_taskbar_and_pager
void
skip_taskbar_and_pager(void)
{
  /*
    window  = the respective client window
    message_type = _NET_WM_STATE
    format = 32
    data.l[0] = the action, as listed below
    data.l[1] = first property to alter
    data.l[2] = second property to alter
    data.l[3] = source indication
    other data.l[] elements = 0

    _NET_WM_STATE_REMOVE 0
    _NET_WM_STATE_ADD 1
    _NET_WM_STATE_TOGGLE 2
  */

  if ((skiptaskbar == FALSE) && (skippager == FALSE))
    return;

  // should we skip the taskbar?
  xw.skip_taskbar = XInternAtom(xw.dpy, "_NET_WM_STATE_SKIP_TASKBAR", False);
  xw.skip_pager = XInternAtom(xw.dpy, "_NET_WM_STATE_SKIP_PAGER", False);

  // See Xlib.h, line 36
  XEvent xevent;
  bzero(&xevent, sizeof(xevent));
  // prepare client message
  // we are interested in the 'xclient' field of the Xevent union
  xevent.type = ClientMessage;
  xevent.xclient.window = xw.win;
  xevent.xclient.message_type = xw.window_state;
  xevent.xclient.format = 32;
  xevent.xclient.data.l[0] = _NET_WM_STATE_ADD;
  xevent.xclient.data.l[1] = (skiptaskbar == TRUE) ? xw.skip_pager : 0;
  xevent.xclient.data.l[2] = (skippager == TRUE) ? xw.skip_pager : 0;
  xevent.xclient.data.l[3] = 0;
  xevent.xclient.data.l[4] = 0;
  // Send Message to root win, see https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html#idm140130317705584 for XCB,
  // for Xlib, as used in this program, the equivalent Root window flags are named:
  // X.h:#define SubstructureNotifyMask              (1L<<19)
  // X.h:#define SubstructureRedirectMask    (1L<<20)
  XSendEvent(xw.dpy, DefaultRootWindow(xw.dpy), False, SubstructureNotifyMask|SubstructureRedirectMask, &xevent);
}

// Assembly:
movl 0x13b45(%rip), %eax     # 0x20ab4
orl 0x13b3b(%rip), %eax     # 0x20ab0
je 0xd065
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq 0x13c3a(%rip), %rdi     # 0x20bc8
leaq 0x8ff1(%rip), %rsi      # 0x15f86
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x6800
movq %rax, 0x13c82(%rip)     # 0x20c28
movq 0x13c1b(%rip), %rdi     # 0x20bc8
leaq 0x8fed(%rip), %rsi      # 0x15fa1
xorl %edx, %edx
callq 0x6800
movq %rax, %r14
movq %rax, 0x13c6b(%rip)     # 0x20c30
movq %rsp, %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60c0
movl $0x21, (%rbx)
movq 0x13bf4(%rip), %rax     # 0x20bd8
movq %rax, 0x20(%rbx)
movq 0x13c31(%rip), %rax     # 0x20c20
movq %rax, 0x28(%rbx)
movl $0x20, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
cmpl $0x1, 0x13aa7(%rip)     # 0x20ab0
movl $0x0, %eax
cmoveq %r14, %rax
movq %rax, 0x40(%rbx)
cmpl $0x1, 0x13a97(%rip)     # 0x20ab4
cmovneq %r15, %r14
movq %r14, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x13b95(%rip), %rdi     # 0x20bc8
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
movl $0x180000, %ecx         # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x66c0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: reload
void
reload(int sig)
{
  /* reload xresources */
  config_init();

  /* colors, fonts */
  xloadcols();
  xunloadfonts();
  xloadfonts(usedfont, 0);

  /* pretend the window just got resized */
  cresize(win.w, win.h);

  redraw();

  /* triggers re-render if we're visible. */
  ttywrite("\033[O", 3, 0);

  signal(SIGUSR1, reload);
}

// Assembly:
pushq %rax
callq 0xcd9f
callq 0xb4d8
callq 0xd0bc
movq 0x13d2b(%rip), %rdi     # 0x20da8
xorps %xmm0, %xmm0
callq 0xd11d
movl 0x13c8d(%rip), %edi     # 0x20d18
movl 0x13c8b(%rip), %esi     # 0x20d1c
callq 0xd449
callq 0x8ca7
leaq 0x8f18(%rip), %rdi      # 0x15fba
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x7a9b
leaq -0x4d(%rip), %rsi       # 0xd066
pushq $0xa
popq %rdi
popq %rax
jmp 0x6070
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: xunloadfonts
void
xunloadfonts(void)
{
  /* Free the loaded fonts in the font cache.  */
  while (frclen > 0)
    XftFontClose(xw.dpy, frc[--frclen].font);

  xunloadfont(&dc.font);
  xunloadfont(&dc.bfont);
  xunloadfont(&dc.ifont);
  xunloadfont(&dc.ibfont);

//  if (frc) free(frc);
}

// Assembly:
pushq %rax
movl 0x13d5d(%rip), %eax     # 0x20e20
testl %eax, %eax
jle 0xd0ec
movq 0x13afa(%rip), %rdi     # 0x20bc8
movq 0x13d53(%rip), %rcx     # 0x20e28
decl %eax
movl %eax, 0x13d43(%rip)     # 0x20e20
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x60f0
jmp 0xd0bd
leaq 0x139ed(%rip), %rdi     # 0x20ae0
callq 0xe6b8
leaq 0x13a19(%rip), %rdi     # 0x20b18
callq 0xe6b8
leaq 0x13a45(%rip), %rdi     # 0x20b50
callq 0xe6b8
leaq 0x13a71(%rip), %rdi     # 0x20b88
popq %rax
jmp 0xe6b8
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
  int col, row;

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

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

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

// Assembly:
testl %edi, %edi
je 0xd453
movl %edi, 0x138c5(%rip)     # 0x20d18
testl %esi, %esi
je 0xd45f
movl %esi, 0x138bf(%rip)     # 0x20d1c
jmp 0xd465
movl 0x138b7(%rip), %esi     # 0x20d1c
pushq %rbp
pushq %rbx
pushq %rax
movl 0x138aa(%rip), %eax     # 0x20d18
movl 0x1396c(%rip), %ecx     # 0x20de0
leal (%rcx,%rcx), %edi
subl %edi, %eax
cltd
idivl 0x138ac(%rip)           # 0x20d2c
movl %eax, %ebx
cmpl $0x2, %eax
pushq $0x1
popq %rbp
cmovll %ebp, %ebx
subl %edi, %esi
movl %esi, %eax
cltd
idivl 0x13892(%rip)           # 0x20d28
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ecx, 0x13882(%rip)     # 0x20d24
movl %ecx, 0x13878(%rip)     # 0x20d20
movl %ebx, %edi
movl %ebp, %esi
callq 0x7f24
movl 0x13875(%rip), %eax     # 0x20d2c
imull %ebx, %eax
imull 0x13867(%rip), %ebp     # 0x20d28
movl %eax, 0x13849(%rip)     # 0x20d10
movl %ebp, 0x13847(%rip)     # 0x20d14
movq 0x136f4(%rip), %rdi     # 0x20bc8
movq 0x13705(%rip), %rsi     # 0x20be0
callq 0x68c0
movq 0x136e1(%rip), %rdi     # 0x20bc8
movq 0x136ea(%rip), %rsi     # 0x20bd8
movl 0x13824(%rip), %edx     # 0x20d18
movl 0x13822(%rip), %ecx     # 0x20d1c
movl 0x137ef(%rip), %r8d     # 0x20cf0
callq 0x6960
movq %rax, 0x136d3(%rip)     # 0x20be0
movq 0x13754(%rip), %rdi     # 0x20c68
movq %rax, %rsi
callq 0x6750
movl 0x137f6(%rip), %edx     # 0x20d18
movl 0x137f4(%rip), %ecx     # 0x20d1c
xorl %edi, %edi
xorl %esi, %esi
callq 0xe676
movq 0x136b0(%rip), %rdi     # 0x20be8
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x6ca2
movq %rax, 0x1369d(%rip)     # 0x20be8
movl 0x137bf(%rip), %edi     # 0x20d10
movl 0x137bd(%rip), %esi     # 0x20d14
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7d2a
// File: /workspace/github_c_makefile_star2_O2/mcaimi[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 0x12505(%rip), %rdi     # 0x20bc8
movq 0x20(%rbx), %rsi
callq 0x60f0
movq 0x30(%rbx), %rdi
callq 0x6060
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xe6e4
popq %rbx
jmp 0x6540
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: xhints
void
xhints(void)
{
  XClassHint class = {opt_name ? opt_name : "st",
                      opt_class ? opt_class : "St"};
  XWMHints wm = {.flags = InputHint, .input = 1};
  XSizeHints *sizeh;

  sizeh = XAllocSizeHints();

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

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

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x120cf(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x725b(%rip), %rcx      # 0x15f2e
cmovneq %rax, %rcx
movq 0x120c2(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x7249(%rip), %rdx      # 0x15f31
cmovneq %rax, %rdx
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x68b0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0x11fee(%rip), %eax     # 0x20d1c
movl %eax, 0x14(%rbx)
movl 0x11fe1(%rip), %ecx     # 0x20d18
movl %ecx, 0x10(%rbx)
movl 0x11fe8(%rip), %edx     # 0x20d28
movl %edx, 0x2c(%rbx)
movl 0x11fe3(%rip), %esi     # 0x20d2c
movl %esi, 0x28(%rbx)
movl 0x11fd2(%rip), %edi     # 0x20d24
leal (%rdi,%rdi), %r8d
movl %r8d, 0x44(%rbx)
movl 0x11fbf(%rip), %r8d     # 0x20d20
leal (%r8,%r8), %r9d
movl %r9d, 0x40(%rbx)
leal (%rdx,%r8,2), %edx
movl %edx, 0x1c(%rbx)
leal (%rsi,%rdi,2), %edx
movl %edx, 0x18(%rbx)
cmpl $0x0, 0x11f6f(%rip)     # 0x20cec
je 0xed99
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl $0x379, %ecx            # imm = 0x379
jmp 0xed9e
movl $0x359, %ecx            # imm = 0x359
movl 0x11f58(%rip), %eax     # 0x20cfc
testb $0x3, %al
je 0xedc9
movq %rcx, (%rbx)
movq 0x11f42(%rip), %rcx     # 0x20cf4
movq %rcx, 0x8(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x6eed(%rip), %rcx      # 0x15cb0
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0x11df8(%rip), %rdi     # 0x20bc8
movq 0x11e01(%rip), %rsi     # 0x20bd8
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x6360
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x60a0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[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 0x61d0
pushq $0x1
popq %rbp
testq %rax, %rax
je 0xee78
movq %rax, %r14
movq 0x11d93(%rip), %rdi     # 0x20bc8
movq %rax, %rsi
callq 0x6840
movq 0x11fe4(%rip), %rdx     # 0x20e28
movslq 0x11fd5(%rip), %rcx     # 0x20e20
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
testq %rax, %rax
je 0xee70
movl %ebx, 0x8(%rdx,%rsi)
andl $0x0, 0xc(%rdx,%rsi)
incl %ecx
movl %ecx, 0x11fb4(%rip)     # 0x20e20
xorl %ebp, %ebp
jmp 0xee78
movq %r14, %rdi
callq 0x6060
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq