LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: selstart
void selstart(int col, int row, int snap) {
  selclear();
  sel.mode = SEL_EMPTY;
  sel.type = SEL_REGULAR;
  sel.alt = IS_SET(MODE_ALTSCREEN);
  sel.snap = snap;
  sel.oe.x = sel.ob.x = col;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  sel.oe.y = sel.ob.y = row;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  selnormalize();

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  if (sel.snap != 0)
    sel.mode = SEL_READY;
  tsetdirt(sel.nb.y, sel.ne.y);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
callq 0x5e00
movl $0x1, 0x13010(%rip)     # 0x18d90
movl $0x1, 0x1300a(%rip)     # 0x18d94
movl 0x1307c(%rip), %eax     # 0x18e0c
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x13018(%rip)     # 0x18dbc
movl -0xc(%rbp), %eax
movl %eax, 0x12feb(%rip)     # 0x18d98
movl -0x4(%rbp), %eax
movl %eax, 0x12ff6(%rip)     # 0x18dac
movl %eax, 0x12ff8(%rip)     # 0x18db4
movl -0x8(%rbp), %eax
movl %eax, 0x12feb(%rip)     # 0x18db0
movl %eax, 0x12fed(%rip)     # 0x18db8
callq 0x5e40
cmpl $0x0, 0x12fc1(%rip)     # 0x18d98
je 0x5de3
movl $0x2, 0x12fad(%rip)     # 0x18d90
movl 0x12fb7(%rip), %edi     # 0x18da0
movl 0x12fb9(%rip), %esi     # 0x18da8
callq 0x5ff0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: selclear
void selclear(void) {
  if (sel.ob.x == -1)
    return;
  sel.mode = SEL_IDLE;
  sel.ob.x = -1;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  tsetdirt(sel.nb.y, sel.ne.y);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x12fa1(%rip)    # 0x18dac
jne 0x5e0f
jmp 0x5e34
movl $0x0, 0x12f77(%rip)     # 0x18d90
movl $0xffffffff, 0x12f89(%rip) # imm = 0xFFFFFFFF
movl 0x12f77(%rip), %edi     # 0x18da0
movl 0x12f79(%rip), %esi     # 0x18da8
callq 0x5ff0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tsetdirt
void tsetdirt(int top, int bot) {
  int i;

  LIMIT(top, 0, term.row - 1);
  LIMIT(bot, 0, term.row - 1);

  for (i = top; i <= bot; i++)
    term.dirty[i] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6007
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x6031
movl -0x4(%rbp), %eax
movl 0x12db0(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x6025
movl 0x12da3(%rip), %eax     # 0x18dc0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x602b
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x6044
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x606e
movl -0x8(%rbp), %eax
movl 0x12d73(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x6062
movl 0x12d66(%rip), %eax     # 0x18dc0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6068
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x609f
movq 0x12d4f(%rip), %rax     # 0x18dd8
movslq -0xc(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x607a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: selextend
void selextend(int col, int row, int type, int done) {
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  int oldey, oldex, oldsby, oldsey, oldtype;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

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

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  oldey = sel.oe.y;
  oldex = sel.oe.x;
  oldsby = sel.nb.y;
  oldsey = sel.ne.y;
  oldtype = sel.type;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  sel.oe.x = col;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  sel.oe.y = row;
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  selnormalize();
  sel.type = type;

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

  sel.mode = done ? SEL_IDLE : SEL_READY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0x12cc5(%rip)     # 0x18d90
jne 0x60d2
jmp 0x61c1
cmpl $0x0, -0x10(%rbp)
je 0x60eb
cmpl $0x1, 0x12cb1(%rip)     # 0x18d90
jne 0x60eb
callq 0x5e00
jmp 0x61c1
movl 0x12cc7(%rip), %eax     # 0x18db8
movl %eax, -0x14(%rbp)
movl 0x12cba(%rip), %eax     # 0x18db4
movl %eax, -0x18(%rbp)
movl 0x12c9d(%rip), %eax     # 0x18da0
movl %eax, -0x1c(%rbp)
movl 0x12c9c(%rip), %eax     # 0x18da8
movl %eax, -0x20(%rbp)
movl 0x12c7f(%rip), %eax     # 0x18d94
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x12c93(%rip)     # 0x18db4
movl -0x8(%rbp), %eax
movl %eax, 0x12c8e(%rip)     # 0x18db8
callq 0x5e40
movl -0xc(%rbp), %eax
movl %eax, 0x12c5c(%rip)     # 0x18d94
movl -0x14(%rbp), %eax
cmpl 0x12c77(%rip), %eax     # 0x18db8
jne 0x6162
movl -0x18(%rbp), %eax
cmpl 0x12c68(%rip), %eax     # 0x18db4
jne 0x6162
movl -0x24(%rbp), %eax
cmpl 0x12c3d(%rip), %eax     # 0x18d94
jne 0x6162
cmpl $0x1, 0x12c30(%rip)     # 0x18d90
jne 0x61ab
movl 0x12c38(%rip), %eax     # 0x18da0
cmpl -0x1c(%rbp), %eax
jge 0x6178
movl 0x12c2d(%rip), %eax     # 0x18da0
movl %eax, -0x28(%rbp)
jmp 0x617e
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl 0x12c1e(%rip), %eax     # 0x18da8
cmpl -0x20(%rbp), %eax
jge 0x6197
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x61a0
movl 0x12c0b(%rip), %eax     # 0x18da8
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %edi
movl -0x30(%rbp), %esi
callq 0x5ff0
movl -0x10(%rbp), %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x12bcf(%rip)     # 0x18d90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: selected
int selected(int x, int y) {
  if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
      sel.alt != IS_SET(MODE_ALTSCREEN))
    return 0;

  if (sel.type == SEL_RECTANGULAR)
    return BETWEEN(y, sel.nb.y, sel.ne.y) && BETWEEN(x, sel.nb.x, sel.ne.x);

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  return BETWEEN(y, sel.nb.y, sel.ne.y) && (y != sel.nb.y || x >= sel.nb.x) &&
    (y != sel.ne.y || x <= sel.ne.x);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, 0x12baf(%rip)     # 0x18d90
je 0x620b
cmpl $-0x1, 0x12bc2(%rip)    # 0x18dac
je 0x620b
movl 0x12bca(%rip), %eax     # 0x18dbc
movl 0x12c14(%rip), %ecx     # 0x18e0c
andl $0x4, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x6217
movl $0x0, -0x4(%rbp)
jmp 0x62dd
cmpl $0x2, 0x12b76(%rip)     # 0x18d94
jne 0x6272
movl 0x12b7a(%rip), %ecx     # 0x18da0
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0xd(%rbp)
jg 0x6265
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x12b6d(%rip), %ecx     # 0x18da8
movb %al, -0xd(%rbp)
jg 0x6265
movl 0x12b56(%rip), %ecx     # 0x18d9c
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0xe(%rbp)
jg 0x625f
movl -0x8(%rbp), %eax
cmpl 0x12b4b(%rip), %eax     # 0x18da4
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x62dd
movl 0x12b28(%rip), %ecx     # 0x18da0
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0xf(%rbp)
jg 0x62d2
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x12b1b(%rip), %ecx     # 0x18da8
movb %al, -0xf(%rbp)
jg 0x62d2
movl -0xc(%rbp), %eax
cmpl 0x12b05(%rip), %eax     # 0x18da0
jne 0x62ad
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x12af4(%rip), %ecx     # 0x18d9c
movb %al, -0xf(%rbp)
jl 0x62d2
movl -0xc(%rbp), %ecx
movb $0x1, %al
cmpl 0x12af0(%rip), %ecx     # 0x18da8
movb %al, -0x10(%rbp)
jne 0x62cc
movl -0x8(%rbp), %eax
cmpl 0x12ade(%rip), %eax     # 0x18da4
setle %al
movb %al, -0x10(%rbp)
movb -0x10(%rbp), %al
movb %al, -0xf(%rbp)
movb -0xf(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tlinelen
int tlinelen(int y) {
  int i = term.col;

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  if (term.line[y][i - 1].mode & ATTR_WRAP)
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
    return i;

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  while (i > 0 && term.line[y][i - 1].u == ' ')
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
    --i;

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl 0x12867(%rip), %eax     # 0x18dc4
movl %eax, -0xc(%rbp)
movq 0x12861(%rip), %rax     # 0x18dc8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x6595
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x65e4
jmp 0x6597
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jle 0x65ca
movq 0x1281f(%rip), %rax     # 0x18dc8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x20, (%rax)
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x65d3
jmp 0x65de
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6597
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: ttyread
size_t ttyread(void) {
  static char buf[BUFSIZ];
  static int buflen = 0;
  int ret, written;

  /* append read bytes to unprocessed bytes */
  // >>>>>>>>>>>>>>>>>>>> sync
  // ==================== sync
  ret = read(cmdfd, buf + buflen, LEN(buf) - buflen);
  // ==================== sync
  // <<<<<<<<<<<<<<<<<<<< sync

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x120a2(%rip), %edi     # 0x18e30
movslq 0x140ab(%rip), %rax     # 0x1ae40
leaq 0x120a4(%rip), %rsi     # 0x18e40
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $-0x1, %eax
je 0x6dcc
jmp 0x6dbc
movl -0xc(%rbp), %eax
testl %eax, %eax
jne 0x6de9
jmp 0x6dc5
xorl %edi, %edi
callq 0x5180
callq 0x5570
movl (%rax), %edi
callq 0x5430
movq %rax, %rsi
leaq 0xaab5(%rip), %rdi      # 0x11897
movb $0x0, %al
callq 0x5a70
movl -0x4(%rbp), %eax
addl 0x1404e(%rip), %eax     # 0x1ae40
movl %eax, 0x14048(%rip)     # 0x1ae40
movl 0x14042(%rip), %esi     # 0x1ae40
leaq 0x1203b(%rip), %rdi     # 0x18e40
xorl %edx, %edx
callq 0x6e60
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
movl 0x14028(%rip), %eax     # 0x1ae40
subl %ecx, %eax
movl %eax, 0x14020(%rip)     # 0x1ae40
cmpl $0x0, 0x14019(%rip)     # 0x1ae40
jle 0x6e4a
movslq -0x8(%rbp), %rax
leaq 0x1200c(%rip), %rsi     # 0x18e40
addq %rax, %rsi
movslq 0x14002(%rip), %rdx     # 0x1ae40
leaq 0x11ffb(%rip), %rdi     # 0x18e40
callq 0x54e0
movslq -0x4(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: twrite
int twrite(const char *buf, int buflen, int show_ctrl) {
  int charsize;
  Rune u;
  int n;

  // >>>>>>>>>>>>>>>>>>>> sync
  // ==================== sync
  // ==================== sync
  // <<<<<<<<<<<<<<<<<<<< sync

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6f72
movl 0x11f81(%rip), %eax     # 0x18e0c
andl $0x40, %eax
cmpl $0x0, %eax
je 0x6ec0
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
leaq -0x18(%rbp), %rsi
callq 0x8910
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6ebe
jmp 0x6f72
jmp 0x6edb
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x6f5c
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
ja 0x6eee
cmpl $0x1f, -0x18(%rbp)
jbe 0x6f07
cmpl $0x7f, -0x18(%rbp)
je 0x6f07
movl $0x80, %eax
cmpl -0x18(%rbp), %eax
ja 0x6f5c
cmpl $0x9f, -0x18(%rbp)
ja 0x6f5c
movl -0x18(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x6f33
movl -0x18(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x18(%rbp)
movl $0x5e, %edi
callq 0x8a40
movl $0x5b, %edi
callq 0x8a40
jmp 0x6f5a
cmpl $0xa, -0x18(%rbp)
je 0x6f58
cmpl $0xd, -0x18(%rbp)
je 0x6f58
cmpl $0x9, -0x18(%rbp)
je 0x6f58
movl -0x18(%rbp), %eax
xorl $0x40, %eax
movl %eax, -0x18(%rbp)
movl $0x5e, %edi
callq 0x8a40
jmp 0x6f5a
jmp 0x6f5c
movl -0x18(%rbp), %edi
callq 0x8a40
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e79
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tattrset
int tattrset(int attr) {
  int i, j;

  for (i = 0; i < term.row - 1; i++) {
    for (j = 0; j < term.col - 1; j++) {
      if (term.line[i][j].mode & attr)
        return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x11959(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x74ce
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x11946(%rip), %ecx     # 0x18dc4
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x74c1
movq 0x1193c(%rip), %rax     # 0x18dc8
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl -0x8(%rbp), %eax
cmpl $0x0, %eax
je 0x74b4
movl $0x1, -0x4(%rbp)
jmp 0x74d5
jmp 0x74b6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7475
jmp 0x74c3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x745e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tsetdirtattr
void tsetdirtattr(int attr) {
  int i, j;

  for (i = 0; i < term.row - 1; i++) {
    for (j = 0; j < term.col - 1; j++) {
      if (term.line[i][j].mode & attr) {
        tsetdirt(i, i);
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl 0x118c5(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7566
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x118b2(%rip), %ecx     # 0x18dc4
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7559
movq 0x118a8(%rip), %rax     # 0x18dc8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x754c
movl -0x8(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x5ff0
jmp 0x7559
jmp 0x754e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7509
jmp 0x755b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x74f2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[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 < 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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x20(%rbp)
movw $0x0, -0x1c(%rbp)
leaq 0xeca0(%rip), %rax      # 0x1670c
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x13724(%rip), %rax     # 0x1b19c
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x11346(%rip)     # 0x18de0
movq -0x18(%rbp), %rax
movq %rax, 0x11343(%rip)     # 0x18de8
movq -0x10(%rbp), %rax
movq %rax, 0x11340(%rip)     # 0x18df0
movl -0x8(%rbp), %eax
movl %eax, 0x1133f(%rip)     # 0x18df8
movq 0x11360(%rip), %rdi     # 0x18e20
movslq 0x112fd(%rip), %rdx     # 0x18dc4
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x50a0
leaq 0xec2f(%rip), %rax      # 0x16708
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x112dd(%rip), %eax     # 0x18dc4
jae 0x7b0b
movq 0x11330(%rip), %rax     # 0x18e20
movl -0x4(%rbp), %ecx
movl $0x1, (%rax,%rcx,4)
leaq 0xec07(%rip), %rax      # 0x16708
movl (%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ade
movl $0x0, 0x112ef(%rip)     # 0x18e04
movl 0x112a5(%rip), %eax     # 0x18dc0
subl $0x1, %eax
movl %eax, 0x112e4(%rip)     # 0x18e08
movl $0x41, 0x112de(%rip)    # 0x18e0c
leaq 0x1128b(%rip), %rdi     # 0x18dc0
addq $0x54, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x50a0
movl $0x0, 0x112c6(%rip)     # 0x18e18
movl $0x0, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jae 0x7b9a
xorl %esi, %esi
movl %esi, %edi
callq 0x7d80
xorl %edi, %edi
callq 0x8090
movl 0x1124f(%rip), %edx     # 0x18dc4
subl $0x1, %edx
movl 0x11242(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x7e50
callq 0x8040
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7b59
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tdumpsel
void tdumpsel(void) {
  char *ptr;

  if ((ptr = getsel())) {
    tprinter(ptr, strlen(ptr));
    free(ptr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x62f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x7cad
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5350
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8760
movq -0x8(%rbp), %rdi
callq 0x5320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x7cd7
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x7d01
movl -0x4(%rbp), %eax
movl 0x110e0(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x7cf5
movl 0x110d3(%rip), %eax     # 0x18dc0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7cfb
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x7d14
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x7d3e
movl -0x8(%rbp), %eax
movl 0x110a3(%rip), %ecx     # 0x18dc0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x7d32
movl 0x11096(%rip), %eax     # 0x18dc0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d38
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x7d5e
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x1109d(%rip)     # 0x18e04
movl -0x8(%rbp), %eax
movl %eax, 0x11098(%rip)     # 0x18e08
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tcursor
void tcursor(int mode) {
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  static TCursor c[2];
  int alt = IS_SET(MODE_ALTSCREEN);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  if (mode == CURSOR_SAVE) {
    c[alt] = term.c;
  } else if (mode == CURSOR_LOAD) {
    term.c = c[alt];
    tmoveto(c[alt].x, c[alt].y);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x10d6b(%rip), %eax     # 0x18e0c
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x80f5
movslq -0x8(%rbp), %rcx
leaq 0x1308d(%rip), %rax     # 0x1b150
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq 0x10d0f(%rip), %rcx     # 0x18de0
movq %rcx, (%rax)
movq 0x10d0d(%rip), %rcx     # 0x18de8
movq %rcx, 0x8(%rax)
movq 0x10d0a(%rip), %rcx     # 0x18df0
movq %rcx, 0x10(%rax)
movl 0x10d08(%rip), %ecx     # 0x18df8
movl %ecx, 0x18(%rax)
jmp 0x8167
cmpl $0x1, -0x4(%rbp)
jne 0x8165
movslq -0x8(%rbp), %rcx
leaq 0x1304a(%rip), %rax     # 0x1b150
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x10cc9(%rip)     # 0x18de0
movq 0x8(%rax), %rcx
movq %rcx, 0x10cc6(%rip)     # 0x18de8
movq 0x10(%rax), %rcx
movq %rcx, 0x10cc3(%rip)     # 0x18df0
movl 0x18(%rax), %eax
movl %eax, 0x10cc2(%rip)     # 0x18df8
movslq -0x8(%rbp), %rcx
leaq 0x1300f(%rip), %rax     # 0x1b150
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %edi
movslq -0x8(%rbp), %rcx
leaq 0x12ffa(%rip), %rax     # 0x1b150
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %esi
callq 0x7d80
jmp 0x8167
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: drawregion
void drawregion(int x1, int y1, int x2, int y2) {
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  int y;

  for (y = y1; y < y2; y++) {
    // >>>>>>>>>>>>>>>>>>>> vim-browse-scrollback
    // ==================== vim-browse-scrollback
    if (!term.dirty[y])
      continue;

    term.dirty[y] = 0;
    xdrawline(term.line[y], x1, y, x2);
    // ==================== vim-browse-scrollback
    // <<<<<<<<<<<<<<<<<<<< vim-browse-scrollback
  }

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x840f
movq 0x10a0f(%rip), %rax     # 0x18dd8
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x83d5
jmp 0x8404
movq 0x109fc(%rip), %rax     # 0x18dd8
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x109da(%rip), %rax     # 0x18dc8
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x4(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0xc580
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x83ba
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: csiparse
void csiparse(void) {
  char *p = csiescseq.buf, *np;
  long int v;

  csiescseq.narg = 0;
  if (*p == '?') {
    csiescseq.priv = 1;
    p++;
  }

  csiescseq.buf[csiescseq.len] = '\0';
  while (p < csiescseq.buf + csiescseq.len) {
    np = NULL;
    v = strtol(p, &np, 10);
    if (np == p)
      v = 0;
    if (v == LONG_MAX || v == LONG_MIN)
      v = -1;
    csiescseq.arg[csiescseq.narg++] = v;
    p = np;
    if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ)
      break;
    p++;
  }
  csiescseq.mode[0] = *p++;
  csiescseq.mode[1] = (p < csiescseq.buf + csiescseq.len) ? *p : '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x11dd1(%rip), %rax     # 0x1aef0
movq %rax, -0x8(%rbp)
movl $0x0, 0x1200f(%rip)     # 0x1b13c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x914c
movb $0x1, 0x11fb8(%rip)     # 0x1b0f8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq 0x11f9d(%rip), %rcx     # 0x1b0f0
leaq 0x11d96(%rip), %rax     # 0x1aef0
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
leaq 0x11d87(%rip), %rcx     # 0x1aef0
addq 0x11f80(%rip), %rcx     # 0x1b0f0
cmpq %rcx, %rax
jae 0x9229
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x5470
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x91a9
movq $0x0, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0x91c9
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
jne 0x91d1
movq $-0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edx
movl 0x11f5f(%rip), %eax     # 0x1b13c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x11f54(%rip)     # 0x1b13c
movslq %eax, %rcx
leaq 0x11cfe(%rip), %rax     # 0x1aef0
movl %edx, 0x20c(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x9216
cmpl $0x10, 0x11f28(%rip)    # 0x1b13c
jne 0x9218
jmp 0x9229
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x915e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, 0x11f00(%rip)      # 0x1b140
movq -0x8(%rbp), %rax
leaq 0x11ca5(%rip), %rcx     # 0x1aef0
addq 0x11e9e(%rip), %rcx     # 0x1b0f0
cmpq %rcx, %rax
jae 0x9263
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x926a
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x926a
movl -0x1c(%rbp), %eax
movb %al, 0x11ece(%rip)      # 0x1b141
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tputtab
void tputtab(int n) {
  uint x = term.c.x;

  if (n > 0) {
    while (x < term.col && n--)
      for (++x; x < term.col && !term.tabs[x]; ++x)
        /* nothing */;
  } else if (n < 0) {
    while (x > 0 && n++)
      for (--x; x > 0 && !term.tabs[x]; --x)
        /* nothing */;
  }
  term.c.x = LIMIT(x, 0, term.col - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0xeba3(%rip), %eax      # 0x18df0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xa2ce
jmp 0xa258
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0xeb61(%rip), %ecx      # 0x18dc4
movb %al, -0x9(%rbp)
jae 0xa27c
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xa285
jmp 0xa2cc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0xeb2b(%rip), %ecx      # 0x18dc4
movb %al, -0xa(%rbp)
jae 0xa2b4
movq 0xeb7b(%rip), %rax      # 0x18e20
movl -0x8(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0xa2bd
jmp 0xa2ca
jmp 0xa2bf
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa28e
jmp 0xa258
jmp 0xa344
cmpl $0x0, -0x4(%rbp)
jge 0xa342
jmp 0xa2d6
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0xb(%rbp)
jbe 0xa2f5
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
testb $0x1, %al
jne 0xa2fe
jmp 0xa340
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0xc(%rbp)
jbe 0xa328
movq 0xeb07(%rip), %rax      # 0x18e20
movl -0x8(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
movb %al, -0xc(%rbp)
movb -0xc(%rbp), %al
testb $0x1, %al
jne 0xa331
jmp 0xa33e
jmp 0xa333
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa307
jmp 0xa2d6
jmp 0xa342
jmp 0xa344
cmpl $0x0, -0x8(%rbp)
jae 0xa351
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0xa37b
movl -0x8(%rbp), %eax
movl 0xea6a(%rip), %ecx      # 0x18dc4
subl $0x1, %ecx
cmpl %ecx, %eax
jbe 0xa36f
movl 0xea5d(%rip), %eax      # 0x18dc4
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa375
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl %eax, 0xea69(%rip)      # 0x18df0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: base64dec
char *base64dec(const char *src) {
  size_t in_len = strlen(src);
  char *result, *dst;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5350
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xa72f
movq -0x10(%rbp), %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
imulq $0x3, %rax, %rdi
addq $0x1, %rdi
callq 0x5a20
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa856
leaq -0x8(%rbp), %rdi
callq 0xa9d0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x6f92(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa9d0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x6f76(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa9d0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x6f5a(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa9d0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x6f3e(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0xa7d5
cmpl $-0x1, -0x28(%rbp)
jne 0xa7d7
jmp 0xa856
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl -0x28(%rbp), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x2c(%rbp)
jne 0xa803
jmp 0xa856
movl -0x28(%rbp), %eax
andl $0xf, %eax
shll $0x4, %eax
movl -0x2c(%rbp), %ecx
andl $0x3c, %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x30(%rbp)
jne 0xa832
jmp 0xa856
movl -0x2c(%rbp), %eax
andl $0x3, %eax
shll $0x6, %eax
orl -0x30(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xa74c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tscrollup
void tscrollup(int orig, int n) {
// ==================== scrollback
// <<<<<<<<<<<<<<<<<<<< scrollback
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  int i;
  Line temp;

  LIMIT(n, 0, term.bot - orig + 1);

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback

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

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  selscroll(orig, -n);
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xad5b
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xad8b
movl -0x8(%rbp), %eax
movl 0xe0a4(%rip), %ecx      # 0x18e08
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xad7f
movl 0xe094(%rip), %eax      # 0x18e08
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xad85
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %esi
movl 0xe02a(%rip), %edx      # 0x18dc4
subl $0x1, %edx
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
subl $0x1, %ecx
xorl %edi, %edi
callq 0x7e50
movl -0x4(%rbp), %edi
addl -0x8(%rbp), %edi
movl 0xe04f(%rip), %esi      # 0x18e08
callq 0x5ff0
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0xe03b(%rip), %ecx      # 0x18e08
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jg 0xae2d
movq 0xdfed(%rip), %rax      # 0x18dc8
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xdfda(%rip), %rax      # 0x18dc8
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xdfc6(%rip), %rax      # 0x18dc8
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xdfb3(%rip), %rax      # 0x18dc8
movl -0xc(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xadc4
movl -0x4(%rbp), %edi
xorl %esi, %esi
subl -0x8(%rbp), %esi
callq 0xb950
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tscrolldown
void tscrolldown(int orig, int n) {
// ==================== scrollback
// <<<<<<<<<<<<<<<<<<<< scrollback
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  int i;
  Line temp;

  LIMIT(n, 0, term.bot - orig + 1);

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback

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

  // >>>>>>>>>>>>>>>>>>>> scrollback
  // ==================== scrollback
  selscroll(orig, n);
  // ==================== scrollback
  // <<<<<<<<<<<<<<<<<<<< scrollback
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xae5b
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xae8b
movl -0x8(%rbp), %eax
movl 0xdfa4(%rip), %ecx      # 0x18e08
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xae7f
movl 0xdf94(%rip), %eax      # 0x18e08
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xae85
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl 0xdf6e(%rip), %esi      # 0x18e08
subl -0x8(%rbp), %esi
callq 0x5ff0
movl 0xdf60(%rip), %esi      # 0x18e08
subl -0x8(%rbp), %esi
addl $0x1, %esi
movl 0xdf10(%rip), %edx      # 0x18dc4
subl $0x1, %edx
movl 0xdf4b(%rip), %ecx      # 0x18e08
xorl %edi, %edi
callq 0x7e50
movl 0xdf3e(%rip), %eax      # 0x18e08
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0xaf33
movq 0xdee7(%rip), %rax      # 0x18dc8
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0xded4(%rip), %rax      # 0x18dc8
movl -0xc(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xdec0(%rip), %rax      # 0x18dc8
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0xdead(%rip), %rax      # 0x18dc8
movl -0xc(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xaecd
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xb950
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: tdeletechar
void tdeletechar(int n) {
  int dst, src, size;
  Glyph *line;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xb508
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb538
movl -0x4(%rbp), %eax
movl 0xd8b3(%rip), %ecx      # 0x18dc4
subl 0xd8d9(%rip), %ecx      # 0x18df0
cmpl %ecx, %eax
jle 0xb52c
movl 0xd8a3(%rip), %eax      # 0x18dc4
subl 0xd8c9(%rip), %eax      # 0x18df0
movl %eax, -0x20(%rbp)
jmp 0xb532
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0xd8ac(%rip), %eax      # 0x18df0
movl %eax, -0x8(%rbp)
movl 0xd8a3(%rip), %eax      # 0x18df0
addl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0xd86b(%rip), %eax      # 0x18dc4
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0xd862(%rip), %rax      # 0x18dc8
movslq 0xd887(%rip), %rcx      # 0x18df4
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x54e0
movl 0xd81e(%rip), %edi      # 0x18dc4
subl -0x4(%rbp), %edi
movl 0xd845(%rip), %esi      # 0x18df4
movl 0xd80f(%rip), %edx      # 0x18dc4
subl $0x1, %edx
movl 0xd836(%rip), %ecx      # 0x18df4
callq 0x7e50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/st.c
// Function: selscroll
void selscroll(int orig, int n) {
  if (sel.ob.x == -1)
    return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, 0xd447(%rip)     # 0x18dac
jne 0xb96c
jmp 0xba51
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0xd429(%rip), %ecx      # 0x18da0
movb %al, -0x9(%rbp)
jg 0xb98e
movl 0xd41e(%rip), %eax      # 0x18da0
cmpl 0xd480(%rip), %eax      # 0x18e08
setle %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0xd404(%rip), %ecx      # 0x18da8
movb %al, -0xa(%rbp)
jg 0xb9bb
movl 0xd3f9(%rip), %eax      # 0x18da8
cmpl 0xd453(%rip), %eax      # 0x18e08
setle %al
movb %al, -0xa(%rbp)
movl -0x10(%rbp), %eax
movb -0xa(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xb9d2
callq 0x5e00
jmp 0xba51
movl -0x4(%rbp), %eax
cmpl 0xd3c5(%rip), %eax      # 0x18da0
jg 0xba4f
movl 0xd3bd(%rip), %eax      # 0x18da0
cmpl 0xd41f(%rip), %eax      # 0x18e08
jg 0xba4f
movl -0x8(%rbp), %eax
addl 0xd3bc(%rip), %eax      # 0x18db0
movl %eax, 0xd3b6(%rip)      # 0x18db0
movl -0x8(%rbp), %eax
addl 0xd3b5(%rip), %eax      # 0x18db8
movl %eax, 0xd3af(%rip)      # 0x18db8
movl 0xd3a1(%rip), %eax      # 0x18db0
cmpl 0xd3ef(%rip), %eax      # 0x18e04
jl 0xba41
movl 0xd393(%rip), %eax      # 0x18db0
cmpl 0xd3e5(%rip), %eax      # 0x18e08
jg 0xba41
movl 0xd38d(%rip), %eax      # 0x18db8
cmpl 0xd3d3(%rip), %eax      # 0x18e04
jl 0xba41
movl 0xd37f(%rip), %eax      # 0x18db8
cmpl 0xd3c9(%rip), %eax      # 0x18e08
jle 0xba48
callq 0x5e00
jmp 0xba4d
callq 0x5e40
jmp 0xba4f
jmp 0xba51
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: clipcopy
void clipcopy(const Arg *dummy) {
  Atom clipboard;

  free(xsel.clipboard);
  xsel.clipboard = NULL;
  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse

  if (xsel.primary != NULL) {
    xsel.clipboard = xstrdup(xsel.primary);
    clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
    XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf76d(%rip), %rdi      # 0x1b420
callq 0x5320
movq $0x0, 0xf75d(%rip) # 0x1b420
cmpq $0x0, 0xf74d(%rip)      # 0x1b418
je 0xbd14
movq 0xf744(%rip), %rdi      # 0x1b418
callq 0x5b70
movq %rax, 0xf740(%rip)      # 0x1b420
movq 0xf5b9(%rip), %rdi      # 0x1b2a0
leaq 0x617d(%rip), %rsi      # 0x11e6b
xorl %edx, %edx
callq 0x5730
movq %rax, -0x10(%rbp)
movq 0xf5a0(%rip), %rdi      # 0x1b2a0
movq -0x10(%rbp), %rsi
movq 0xf5a5(%rip), %rdx      # 0x1b2b0
xorl %eax, %eax
movl %eax, %ecx
callq 0x55f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[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();
  // >>>>>>>>>>>>>>>>>>>> clipboard
  // ==================== clipboard
  // ==================== clipboard
  // <<<<<<<<<<<<<<<<<<<< clipboard
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbd59
jmp 0xbdab
movq 0xf6b8(%rip), %rdi      # 0x1b418
callq 0x5320
movq -0x8(%rbp), %rax
movq %rax, 0xf6a8(%rip)      # 0x1b418
movq 0xf529(%rip), %rdi      # 0x1b2a0
movq 0xf532(%rip), %rdx      # 0x1b2b0
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x55f0
movq 0xf50d(%rip), %rdi      # 0x1b2a0
movl $0x1, %esi
callq 0x5890
cmpq 0xf50c(%rip), %rax      # 0x1b2b0
je 0xbdab
callq 0x5e00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xloadcolor
int xloadcolor(int i, const char *name, Color *ncolor) {
  XRenderColor color = {.alpha = 0xffff};

  if (!name) {
    if (BETWEEN(i, 16, 255)) {  /* 256 color */
      if (i < 6 * 6 * 6 + 16) { /* same colors as xterm */
        color.red = sixd_to_16bit(((i - 16) / 36) % 6);
        color.green = sixd_to_16bit(((i - 16) / 6) % 6);
        color.blue = sixd_to_16bit(((i - 16) / 1) % 6);
      } else { /* greyscale */
        color.red = 0x0808 + 0x0a0a * (i - (6 * 6 * 6 + 16));
        color.green = color.blue = color.red;
      }
      return XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, ncolor);
    } else
      name = colorname[i];
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x5eae(%rip), %rax      # 0x11db8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc001
movl $0x10, %eax
cmpl -0x8(%rbp), %eax
jg 0xbfec
cmpl $0xff, -0x8(%rbp)
jg 0xbfec
cmpl $0xe8, -0x8(%rbp)
jge 0xbfa2
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x24, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0xed30
movw %ax, -0x20(%rbp)
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0xed30
movw %ax, -0x1e(%rbp)
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl $0x1, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0xed30
movw %ax, -0x1c(%rbp)
jmp 0xbfc5
movl -0x8(%rbp), %eax
subl $0xe8, %eax
imull $0xa0a, %eax, %eax      # imm = 0xA0A
addl $0x808, %eax            # imm = 0x808
movw %ax, -0x20(%rbp)
movw -0x20(%rbp), %ax
movw %ax, -0x1c(%rbp)
movw %ax, -0x1e(%rbp)
movq 0xf2d4(%rip), %rdi      # 0x1b2a0
movq 0xf33d(%rip), %rsi      # 0x1b310
movq 0xf2ce(%rip), %rdx      # 0x1b2a8
movq -0x18(%rbp), %r8
leaq -0x20(%rbp), %rcx
callq 0x56d0
movl %eax, -0x4(%rbp)
jmp 0xc026
movslq -0x8(%rbp), %rcx
leaq 0xa719(%rip), %rax      # 0x16710
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xc001
movq 0xf298(%rip), %rdi      # 0x1b2a0
movq 0xf301(%rip), %rsi      # 0x1b310
movq 0xf292(%rip), %rdx      # 0x1b2a8
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x54d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xsettitle
void xsettitle(char *p) {
  XTextProperty prop;
  DEFAULT(p, opt_title);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc4dd
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xc4e8
movq 0xeedc(%rip), %rax      # 0x1b3c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0xeda9(%rip), %rdi      # 0x1b2a0
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x5400
movq 0xed8b(%rip), %rdi      # 0x1b2a0
movq 0xed94(%rip), %rsi      # 0x1b2b0
leaq -0x28(%rbp), %rdx
callq 0x53c0
movq 0xed74(%rip), %rdi      # 0x1b2a0
movq 0xed7d(%rip), %rsi      # 0x1b2b0
movq 0xed9e(%rip), %rcx      # 0x1b2d8
leaq -0x28(%rbp), %rdx
callq 0x5420
movq -0x28(%rbp), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)