LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0xe93d(%rip), %eax      # 0x157c0
cmpl $0x2, %eax
jl 0x6ec9
decl %eax
movl 0xe934(%rip), %ecx      # 0x157c4
leal -0x1(%rcx), %edx
movq 0xe92e(%rip), %rsi      # 0x157c8
shlq $0x4, %rdx
xorl %r8d, %r8d
cmpl $0x2, %ecx
jl 0x6ec1
movq (%rsi,%r8,8), %r9
xorl %r10d, %r10d
movzwl 0x4(%r9,%r10), %r11d
testl %edi, %r11d
jne 0x6ecc
addq $0x10, %r10
cmpq %r10, %rdx
jne 0x6ead
incq %r8
cmpq %rax, %r8
jne 0x6ea1
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x2, 0xe8e7(%rip)      # 0x157c0
jl 0x6f3a
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r14d, %r14d
movl 0xe8da(%rip), %eax      # 0x157c4
cmpl $0x2, %eax
jl 0x6f21
decl %eax
movq 0xe8d0(%rip), %rcx      # 0x157c8
movq (%rcx,%r14,8), %rcx
shlq $0x4, %rax
xorl %edx, %edx
movzwl 0x4(%rcx,%rdx), %esi
testl %ebx, %esi
jne 0x6f16
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x6f02
jmp 0x6f21
movl %r14d, %edi
movl %r14d, %esi
callq 0x61bb
incq %r14
movslq 0xe895(%rip), %rax      # 0x157c0
decq %rax
cmpq %rax, %r14
jl 0x6ee4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0xe13e(%rip), %rax      # 0x154dc
movl (%rax), %eax
leaq 0x107f5(%rip), %rcx     # 0x17b9c
movl (%rcx), %ecx
movl $0x0, 0xe42d(%rip)      # 0x157e0
movw $0x0, 0xe428(%rip)      # 0x157e4
movl %eax, 0xe426(%rip)      # 0x157e8
movl %ecx, 0xe424(%rip)      # 0x157ec
movq $0x0, 0xe41d(%rip) # 0x157f0
movb $0x0, 0xe41e(%rip)      # 0x157f8
movq 0xe43f(%rip), %rdi      # 0x15820
movslq 0xe3dc(%rip), %rbx      # 0x157c4
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x50a0
leaq 0xe0db(%rip), %rax      # 0x154d8
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x741f
movq 0xe416(%rip), %rdx      # 0x15820
movl 0xe3b4(%rip), %esi      # 0x157c4
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x7410
movl $0x0, 0xe3db(%rip)      # 0x15804
movl 0xe391(%rip), %eax      # 0x157c0
decl %eax
movl %eax, 0xe3d1(%rip)      # 0x15808
movl $0x41, 0xe3cb(%rip)     # 0x1580c
movq $0x3030303, 0xe3c8(%rip) # imm = 0x3030303
movl $0x1, %ebx
leaq 0x106f8(%rip), %r14     # 0x17b50
movb 0xe39a(%rip), %dl       # 0x157f8
movl 0xe35c(%rip), %ecx      # 0x157c0
movl %edx, %eax
andb $-0x2, %al
movb %al, 0xe38a(%rip)       # 0x157f8
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x7488
movl 0xe386(%rip), %esi      # 0x15808
movl 0xe37c(%rip), %eax      # 0x15804
movl 0xe336(%rip), %edx      # 0x157c4
decl %edx
movl %esi, %edi
sarl $0x1f, %edi
andl %esi, %edi
movl %edx, %esi
sarl $0x1f, %esi
andl %edx, %esi
testl %eax, %eax
cmovgl %eax, %edi
movl %esi, 0xe347(%rip)      # 0x157f0
movl %edi, 0xe345(%rip)      # 0x157f4
movl 0xe357(%rip), %eax      # 0x1580c
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0xe313(%rip), %xmm0     # 0x157e0
movups %xmm0, (%r14,%rsi)
movups 0xe313(%rip), %xmm0     # 0x157ec
movups %xmm0, 0xc(%r14,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x75de
callq 0x774c
decl %ebx
je 0x7458
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: tdumpsel
void tdumpsel(void) {
  char *ptr;

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

// Assembly:
pushq %rbx
callq 0x63a4
testq %rax, %rax
je 0x7571
movq %rax, %rbx
movq %rax, %rdi
callq 0x5350
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7c3c
movq %rbx, %rdi
popq %rbx
jmp 0x5320
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: tclearregion
void tclearregion(int x1, int y1, int x2, int y2) {
  int x, y, temp;
  Glyph *gp;

  if (x1 > x2)
    temp = x1, x1 = x2, x2 = temp;
  if (y1 > y2)
    temp = y1, y1 = y2, y2 = temp;

  // >>>>>>>>>>>>>>>>>>>> vim-browse
  // ==================== vim-browse
  LIMIT(x1, 0, term.col - 1);
  LIMIT(x2, 0, term.col - 1);
  // ==================== vim-browse
  // <<<<<<<<<<<<<<<<<<<< vim-browse
  LIMIT(y1, 0, term.row - 1);
  LIMIT(y2, 0, term.row - 1);

  for (y = y1; y <= y2; y++) {
    term.dirty[y] = 1;
    for (x = x1; x <= x2; x++) {
      gp = &term.line[y][x];
      // >>>>>>>>>>>>>>>>>>>> vim-browse
      // ==================== vim-browse
      if (selected(x, y))
        selclear();
      // ==================== vim-browse
      // <<<<<<<<<<<<<<<<<<<< vim-browse
      gp->fg = term.c.attr.fg;
      gp->bg = term.c.attr.bg;
      gp->mode = 0;
      gp->u = ' ';
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, %edi
movl %edx, %r8d
cmovgl %edi, %r8d
cmovll %edi, %edx
cmpl %ecx, %esi
movl %ecx, %eax
cmovll %esi, %eax
cmovgl %esi, %ecx
movq $0x0, 0x8(%rsp)
movl $0x0, %r15d
testl %edx, %edx
js 0x7626
movl 0xe1a8(%rip), %r15d     # 0x157c4
decl %r15d
cmpl %r15d, %edx
cmovll %edx, %r15d
testl %r8d, %r8d
js 0x763f
movl 0xe193(%rip), %edx      # 0x157c4
decl %edx
cmpl %edx, %r8d
cmovll %r8d, %edx
movq %rdx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x0, %edx
testl %eax, %eax
js 0x765d
movl 0xe16a(%rip), %edx      # 0x157c0
decl %edx
cmpl %edx, %eax
cmovll %eax, %edx
testl %ecx, %ecx
js 0x7672
movl 0xe159(%rip), %eax      # 0x157c0
decl %eax
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %eax, 0x4(%rsp)
cmpl 0x4(%rsp), %edx
jg 0x773d
movslq %r15d, %rcx
movq 0x8(%rsp), %rax
leal 0x1(%rax), %r13d
movslq %edx, %rbx
incl 0x4(%rsp)
shlq $0x4, %rcx
orq $0xc, %rcx
movq %rcx, 0x10(%rsp)
movq 0xe135(%rip), %rax      # 0x157d8
movl $0x1, (%rax,%rbx,4)
cmpl 0x8(%rsp), %r15d
jg 0x7730
movq 0x10(%rsp), %r14
movl %r15d, %ebp
movq 0xe108(%rip), %rax      # 0x157c8
movq (%rax,%rbx,8), %r12
movl %ebp, %edi
movl %ebx, %esi
callq 0x6318
testl %eax, %eax
je 0x76ff
cmpl $-0x1, 0xe0d4(%rip)     # 0x157ac
je 0x76ff
movl $0x0, 0xe0ac(%rip)      # 0x15790
movl $0xffffffff, 0xe0be(%rip) # imm = 0xFFFFFFFF
movl 0xe0ac(%rip), %edi      # 0x157a0
movl 0xe0ae(%rip), %esi      # 0x157a8
callq 0x61bb
movl 0xe0e3(%rip), %eax      # 0x157e8
movl %eax, -0x4(%r12,%r14)
movl 0xe0dc(%rip), %eax      # 0x157ec
movl %eax, (%r12,%r14)
movw $0x0, -0x8(%r12,%r14)
movl $0x20, -0xc(%r12,%r14)
incl %ebp
addq $0x10, %r14
cmpl %ebp, %r13d
jne 0x76b9
incq %rbx
cmpl %ebx, 0x4(%rsp)
jne 0x769c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0xe061(%rip), %ecx      # 0x1580c
shrl $0x2, %ecx
andl $0x1, %ecx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rdx
leaq 0x10390(%rip), %rax     # 0x17b50
addq %rcx, %rax
addq %rdx, %rax
testl %edi, %edi
je 0x77ea
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xe014(%rip)     # 0x157ec
movups %xmm0, 0xe001(%rip)     # 0x157e0
movl 0x10(%rax), %edi
movl 0x14(%rax), %esi
jmp 0x7573
movups 0xdffb(%rip), %xmm0     # 0x157ec
movups %xmm0, 0xc(%rax)
movups 0xdfe4(%rip), %xmm0     # 0x157e0
movups %xmm0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/st.c
// Function: tsetchar
void tsetchar(Rune u, Glyph *attr, int x, int y) {
  static char *vt100_0[62] = {
      /* 0x41 - 0x7e */
      "↑", "↓", "→", "←", "█", "▚", "☃",      /* A - G */
      0,   0,   0,   0,   0,   0,   0,   0,   /* H - O */
      0,   0,   0,   0,   0,   0,   0,   0,   /* P - W */
      0,   0,   0,   0,   0,   0,   0,   " ", /* X - _ */
      "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
      "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
      "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
      "│", "≤", "≥", "π", "≠", "£", "·",      /* x - ~ */
  };

  /*
   * The table is proudly stolen from rxvt.
   */
  if (term.trantbl[term.charset] == CS_GRAPHIC0 && BETWEEN(u, 0x41, 0x7e) &&
      vt100_0[u - 0x41])
    utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);

  if (term.line[y][x].mode & ATTR_WIDE) {
    if (x + 1 < term.col) {
      term.line[y][x + 1].u = ' ';
      term.line[y][x + 1].mode &= ~ATTR_WDUMMY;
    }
  } else if (term.line[y][x].mode & ATTR_WDUMMY) {
    term.line[y][x - 1].u = ' ';
    term.line[y][x - 1].mode &= ~ATTR_WIDE;
  }

  term.dirty[y] = 1;
  term.line[y][x] = *attr;
  term.line[y][x].u = u;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl %edi, 0x4(%rsp)
addl $-0x41, %edi
cmpl $0x3d, %edi
ja 0x8ea7
leaq 0xc94d(%rip), %rax      # 0x157c0
movslq 0xc99e(%rip), %rcx      # 0x15818
cmpb $0x0, 0x54(%rcx,%rax)
jne 0x8ea7
movl %edi, %eax
leaq -0x7(%rax), %rcx
cmpq $0x17, %rcx
jb 0x8ea7
leaq 0x99ac(%rip), %rcx      # 0x12840
movq (%rcx,%rax,8), %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x7d1b
movq 0xc91a(%rip), %rcx      # 0x157c8
movslq %ebp, %rax
movq (%rcx,%rax,8), %rdx
movslq %ebx, %rcx
shlq $0x4, %rcx
movzwl 0x4(%rdx,%rcx), %esi
btl $0x9, %esi
jb 0x8ed5
btl $0xa, %esi
jae 0x8ef6
decl %ebx
movw $0xfdff, %si            # imm = 0xFDFF
jmp 0x8ee3
incl %ebx
movw $0xfbff, %si            # imm = 0xFBFF
cmpl 0xc8e3(%rip), %ebx      # 0x157c4
jge 0x8ef6
movslq %ebx, %rdi
shlq $0x4, %rdi
movl $0x20, (%rdx,%rdi)
andw %si, 0x4(%rdx,%rdi)
movq 0xc8db(%rip), %rsi      # 0x157d8
movl $0x1, (%rsi,%rax,4)
movups 0xc8d5(%rip), %xmm0     # 0x157e0
movups %xmm0, (%rdx,%rcx)
movl 0x4(%rsp), %edx
movq 0xc8ae(%rip), %rsi      # 0x157c8
movq (%rsi,%rax,8), %rax
movl %edx, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0xc8c2(%rip), %eax      # 0x157f0
testl %edi, %edi
jle 0x8f6b
movl 0xc88c(%rip), %ecx      # 0x157c4
cmpl %ecx, %eax
jae 0x8fa5
movq 0xc8dd(%rip), %rdx      # 0x15820
subl $0x1, %edi
jb 0x8fa5
leal 0x1(%rax), %esi
cmpl %esi, %ecx
cmoval %ecx, %esi
leal -0x1(%rsi), %r8d
cmpl %eax, %r8d
je 0x8f63
incl %eax
cmpl $0x0, (%rdx,%rax,4)
je 0x8f54
jmp 0x8f65
movl %esi, %eax
cmpl %ecx, %eax
jb 0x8f43
jmp 0x8fa5
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8fa5
movq 0xc89f(%rip), %rcx      # 0x15820
incl %edi
decl %eax
movl %eax, %edx
subl $0x1, %edx
jb 0x8fa3
movl %eax, %eax
cmpl $0x0, (%rcx,%rax,4)
movl %edx, %eax
je 0x8f87
leal 0x1(%rdx), %eax
testl %edi, %edi
jne 0x8f81
incl %edx
movl %edx, %eax
jmp 0x8fa5
xorl %eax, %eax
movl 0xc819(%rip), %ecx      # 0x157c4
decl %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, 0xc838(%rip)      # 0x157f0
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
callq 0x5350
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incq %rdi
callq 0x5e3c
leaq 0x5219(%rip), %r12      # 0xe470
movq %rax, 0x8(%rsp)
movq %rax, %r15
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x9311
movq %rbx, %rdi
callq 0x9329
movzbl %al, %eax
movb (%rax,%r12), %r14b
movq %rbx, %rdi
callq 0x9329
movzbl %al, %eax
movb (%rax,%r12), %r13b
movq %rbx, %rdi
callq 0x9329
movzbl %al, %eax
movb (%rax,%r12), %bpl
movq %rbx, %rdi
callq 0x9329
cmpb $-0x1, %r14b
sete %cl
cmpb $-0x1, %r13b
sete %dl
orb %cl, %dl
jne 0x9307
movzbl %al, %eax
movb (%rax,%r12), %al
shlb $0x2, %r14b
movl %r13d, %ecx
shrb $0x4, %cl
andb $0x3, %cl
orb %r14b, %cl
movb %cl, (%r15)
cmpb $-0x1, %bpl
je 0x92fe
shlb $0x4, %r13b
movl %ebp, %ecx
shrb $0x2, %cl
andb $0xf, %cl
orb %r13b, %cl
movb %cl, 0x1(%r15)
cmpb $-0x1, %al
je 0x9303
shlb $0x6, %bpl
orb %bpl, %al
movb %al, 0x2(%r15)
addq $0x3, %r15
movb $0x1, %al
jmp 0x9309
incq %r15
jmp 0x9307
addq $0x2, %r15
xorl %eax, %eax
testb %al, %al
jne 0x925f
movb $0x0, (%r15)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edi, %ebx
testl %esi, %esi
js 0x9435
movl 0xc3e2(%rip), %r14d     # 0x15808
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0x9438
xorl %r14d, %r14d
movl 0xc386(%rip), %edx      # 0x157c4
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x75de
movl 0xc3af(%rip), %esi      # 0x15808
movl %ebp, %edi
callq 0x61bb
movl 0xc3a2(%rip), %eax      # 0x15808
subl %r14d, %eax
subl %ebx, %eax
jl 0x94a0
movslq %ebx, %rdx
movslq %r14d, %rcx
movq 0xc34e(%rip), %rsi      # 0x157c8
addq %rdx, %rcx
leaq (%rsi,%rcx,8), %rcx
leaq (%rsi,%rdx,8), %rdx
incl %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
movq %rdi, (%rcx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0x9489
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9aea
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
js 0x94d1
movl 0xc346(%rip), %r14d     # 0x15808
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0x94d4
xorl %r14d, %r14d
movl 0xc32e(%rip), %esi      # 0x15808
subl %r14d, %esi
movl %ebx, %edi
callq 0x61bb
movl 0xc31e(%rip), %ecx      # 0x15808
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0xc2cd(%rip), %edx      # 0x157c4
decl %edx
xorl %edi, %edi
callq 0x75de
movslq 0xc301(%rip), %rax      # 0x15808
leal (%r14,%rbx), %ecx
cmpl %ecx, %eax
jl 0x9545
movslq %r14d, %rdi
movslq %ecx, %rcx
movq 0xc2ac(%rip), %rdx      # 0x157c8
incq %rax
shlq $0x3, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
movq -0x8(%rdx,%rax,8), %rdi
movq -0x8(%rsi,%rax,8), %r8
movq %r8, -0x8(%rdx,%rax,8)
movq %rdi, -0x8(%rsi,%rax,8)
decq %rax
cmpq %rcx, %rax
jg 0x9529
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9aea
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edi, %edi
js 0x98e0
movl 0xbef1(%rip), %eax      # 0x157c4
subl 0xbf17(%rip), %eax      # 0x157f0
cmpl %edi, %eax
cmovgel %edi, %eax
jmp 0x98e2
xorl %eax, %eax
pushq %rbx
movslq 0xbf06(%rip), %rdi      # 0x157f0
movslq %eax, %rbx
leaq (%rdi,%rbx), %rsi
movslq 0xbecc(%rip), %rdx      # 0x157c4
movslq %esi, %rax
subq %rax, %rdx
movq 0xbec3(%rip), %rax      # 0x157c8
movslq 0xbee8(%rip), %rcx      # 0x157f4
movq (%rax,%rcx,8), %rax
shlq $0x4, %rdi
addq %rax, %rdi
shlq $0x4, %rsi
addq %rax, %rsi
shlq $0x4, %rdx
callq 0x54e0
movl 0xbe97(%rip), %edx      # 0x157c4
movl %edx, %edi
subl %ebx, %edi
movl 0xbebd(%rip), %ecx      # 0x157f4
decl %edx
movl %ecx, %esi
popq %rbx
jmp 0x75de
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $-0x1, 0xbcbb(%rip)     # 0x157ac
je 0x9b9c
movl %esi, %eax
movl %edi, %ecx
movl 0xbc9f(%rip), %edi      # 0x157a0
cmpl %ecx, %edi
setge %sil
movl 0xbcfb(%rip), %edx      # 0x15808
cmpl %edx, %edi
setle %r8b
andb %sil, %r8b
movl 0xbc8c(%rip), %esi      # 0x157a8
cmpl %ecx, %esi
setl %r9b
cmpl %edx, %esi
setg %r10b
orb %r9b, %r10b
cmpb %r10b, %r8b
je 0x9b83
cmpl %edx, %edi
setle %r8b
cmpl %ecx, %edi
setge %cl
andb %r8b, %cl
cmpb $0x1, %cl
jne 0x9b9c
movl 0xbc67(%rip), %ecx      # 0x157b0
addl %eax, %ecx
movl %ecx, 0xbc5f(%rip)      # 0x157b0
addl 0xbc61(%rip), %eax      # 0x157b8
movl %eax, 0xbc5b(%rip)      # 0x157b8
movl 0xbca0(%rip), %r8d      # 0x15804
cmpl %r8d, %ecx
jl 0x9b83
cmpl %edx, %ecx
setg %cl
cmpl %r8d, %eax
setl %r8b
cmpl %edx, %eax
setg %al
orb %cl, %al
orb %r8b, %al
cmpb $0x1, %al
jne 0x9b9d
movl $0x0, 0xbc03(%rip)      # 0x15790
movl $0xffffffff, 0xbc15(%rip) # imm = 0xFFFFFFFF
jmp 0x61bb
retq
jmp 0x60bf
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq 0xe186(%rip), %rdi      # 0x17e18
callq 0x5320
movq $0x0, 0xe176(%rip) # 0x17e18
movq 0xe167(%rip), %rdi      # 0x17e10
testq %rdi, %rdi
je 0x9ce8
callq 0x5f2a
movq %rax, 0xe15e(%rip)      # 0x17e18
movq 0xdfdf(%rip), %rdi      # 0x17ca0
leaq 0x4ef3(%rip), %rsi      # 0xebbb
xorl %edx, %edx
callq 0x5730
movq 0xdfca(%rip), %rdi      # 0x17ca0
movq 0xdfd3(%rip), %rdx      # 0x17cb0
movq %rax, %rsi
xorl %ecx, %ecx
popq %rax
jmp 0x55f0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x9d51
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe10c(%rip), %rdi      # 0x17e10
callq 0x5320
movq %r14, 0xe100(%rip)      # 0x17e10
movq 0xdf89(%rip), %rdi      # 0x17ca0
movq 0xdf92(%rip), %rdx      # 0x17cb0
movl $0x1, %esi
movq %rbx, %rcx
callq 0x55f0
movq 0xdf6e(%rip), %rdi      # 0x17ca0
movl $0x1, %esi
callq 0x5880
cmpq 0xdf6d(%rip), %rax      # 0x17cb0
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
jne 0x6090
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq %rdx, %r8
movq %rsi, %rcx
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, (%rsp)
testq %rsi, %rsi
jne 0x9f1f
leal -0x10(%rdi), %eax
cmpl $0xef, %eax
ja 0x9f11
cmpl $0xe7, %edi
jg 0x9f3a
movl %eax, %edx
imulq $0x38e38e39, %rdx, %rsi # imm = 0x38E38E39
shrq $0x23, %rsi
imulq $0x2aaaaaab, %rsi, %rcx # imm = 0x2AAAAAAB
shrq $0x20, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %esi
imull $0x2828, %esi, %edi     # imm = 0x2828
movl $0x3737, %ecx           # imm = 0x3737
addl %ecx, %edi
testl %esi, %esi
cmovel %esi, %edi
movw %di, (%rsp)
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
imulq %rdx, %rsi
shrq $0x22, %rsi
imulq $0x2aaaaaab, %rsi, %rdx # imm = 0x2AAAAAAB
shrq $0x20, %rdx
addl %edx, %edx
leal (%rdx,%rdx,2), %edx
movl %esi, %edi
subl %edx, %edi
imull $0x2828, %edi, %edx     # imm = 0x2828
addl %ecx, %edx
testl %edi, %edi
cmovel %edi, %edx
movw %dx, 0x2(%rsp)
addl %esi, %esi
leal (%rsi,%rsi,2), %edx
subl %edx, %eax
imull $0x2828, %eax, %edx     # imm = 0x2828
addl %ecx, %edx
testl %eax, %eax
cmovel %eax, %edx
movw %dx, 0x4(%rsp)
jmp 0x9f53
movslq %edi, %rax
leaq 0x8b15(%rip), %rcx      # 0x12a30
movq (%rcx,%rax,8), %rcx
movq 0xdd7a(%rip), %rdi      # 0x17ca0
movq 0xdde3(%rip), %rsi      # 0x17d10
movq 0xdd74(%rip), %rdx      # 0x17ca8
popq %rax
jmp 0x54d0
imull $0xa0a, %edi, %eax      # imm = 0xA0A
addl $0xffffeef8, %eax       # imm = 0xFFFFEEF8
movw %ax, (%rsp)
movw %ax, 0x4(%rsp)
movw %ax, 0x2(%rsp)
movq 0xdd46(%rip), %rdi      # 0x17ca0
movq 0xddaf(%rip), %rsi      # 0x17d10
movq 0xdd40(%rip), %rdx      # 0x17ca8
movq %rsp, %rcx
callq 0x56d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
jne 0xa2f1
movq 0xdacf(%rip), %rdi      # 0x17dc0
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0xd9a0(%rip), %rdi      # 0x17ca0
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %r8
callq 0x5400
movq 0xd982(%rip), %rdi      # 0x17ca0
movq 0xd98b(%rip), %rsi      # 0x17cb0
movq %rbx, %rdx
callq 0x53c0
movq 0xd96c(%rip), %rdi      # 0x17ca0
movq 0xd975(%rip), %rsi      # 0x17cb0
movq 0xd996(%rip), %rcx      # 0x17cd8
movq %rbx, %rdx
callq 0x5420
movq (%rbx), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: xximspot
void xximspot(int x, int y) {
  if (xw.ime.xic == NULL)
    return;

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

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

// Assembly:
movl %edi, %eax
movq 0xcd2a(%rip), %rdi      # 0x17cf0
testq %rdi, %rdi
je 0xb006
imull 0xcde2(%rip), %eax      # 0x17db4
addl $0x2, %eax
movw %ax, 0xcd1c(%rip)       # 0x17cf8
incl %esi
imull 0xcdcb(%rip), %esi      # 0x17db0
addl $0x2, %esi
movw %si, 0xcd0b(%rip)       # 0x17cfa
movq 0xcd0a(%rip), %rdx      # 0x17d00
leaq 0x3b9f(%rip), %rsi      # 0xeb9c
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x5250
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: ximopen
int ximopen(Display *dpy) {
  XIMCallback imdestroy = {.client_data = NULL, .callback = ximdestroy};
  XICCallback icdestroy = {.client_data = NULL, .callback = xicdestroy};

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

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

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

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

  return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movups 0x715c(%rip), %xmm0     # 0x13240
movaps %xmm0, 0x10(%rsp)
movups 0x7160(%rip), %xmm0     # 0x13250
movaps %xmm0, (%rsp)
movq 0xbba5(%rip), %rdi      # 0x17ca0
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5690
movq %rax, 0xbbd9(%rip)      # 0x17ce8
testq %rax, %rax
je 0xc1b3
leaq 0x2d7e(%rip), %rsi      # 0xee9d
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x55a0
testq %rax, %rax
jne 0xc1bb
leaq 0x2d9d(%rip), %rsi      # 0xeedd
leaq 0xbbb1(%rip), %rdx      # 0x17cf8
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x56c0
movq %rax, 0xbba7(%rip)      # 0x17d00
cmpq $0x0, 0xbb8f(%rip)      # 0x17cf0
jne 0xc1a4
movq 0xbb7e(%rip), %rdi      # 0x17ce8
movq 0xbb3f(%rip), %r8       # 0x17cb0
movq %rsp, %r10
leaq 0x2d6f(%rip), %rsi      # 0xeeea
leaq 0x2d73(%rip), %rcx      # 0xeef5
leaq 0x2d14(%rip), %r9       # 0xee9d
movl $0x408, %edx            # imm = 0x408
xorl %eax, %eax
pushq $0x0
pushq %r10
callq 0x5030
addq $0x10, %rsp
movq %rax, 0xbb4c(%rip)      # 0x17cf0
movl $0x1, %ebx
cmpq $0x0, 0xbb3f(%rip)      # 0x17cf0
je 0xc1c5
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x5c76
jmp 0xc139
callq 0x5c98
jmp 0xc1b3
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: xhints
void xhints(void) {
  // >>>>>>>>>>>>>>>>>>>> xresources
  // ==================== xresources
  XClassHint class = {opt_name ? opt_name : termname,
                      opt_class ? opt_class : termname};
  // ==================== xresources
  // <<<<<<<<<<<<<<<<<<<< xresources
  XWMHints wm = {.flags = InputHint, .input = 1};
  XSizeHints *sizeh;

  sizeh = XAllocSizeHints();

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

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

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0xbbef(%rip), %rax      # 0x17df0
testq %rax, %rax
movq 0x92c5(%rip), %rcx      # 0x154d0
cmoveq %rcx, %rax
movq %rax, (%rsp)
movq 0xbbb6(%rip), %rax      # 0x17dd0
testq %rax, %rax
cmoveq %rcx, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x1, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x57a0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0xbb45(%rip), %eax      # 0x17dac
movl %eax, 0x14(%rbx)
movl 0xbb38(%rip), %ecx      # 0x17da8
movl %ecx, 0x10(%rbx)
movl 0xbb37(%rip), %edx      # 0x17db0
movl %edx, 0x2c(%rbx)
movl 0xbb32(%rip), %esi      # 0x17db4
movl %esi, 0x28(%rbx)
movabsq $0x400000004, %rdi      # imm = 0x400000004
movq %rdi, 0x40(%rbx)
addl $0x4, %edx
movl %edx, 0x1c(%rbx)
addl $0x4, %esi
movl %esi, 0x18(%rbx)
cmpl $0x0, 0xbae6(%rip)      # 0x17d8c
je 0xc2bb
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl 0xbad7(%rip), %eax      # 0x17d98
testb $0x3, %al
je 0xc2ef
orw $0x201, (%rbx)          # imm = 0x201
movl 0xbac0(%rip), %ecx      # 0x17d90
movl %ecx, 0x8(%rbx)
movl 0xbabb(%rip), %ecx      # 0x17d94
movl %ecx, 0xc(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x3097(%rip), %rcx      # 0xf380
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0xb9aa(%rip), %rdi      # 0x17ca0
movq 0xb9b3(%rip), %rsi      # 0x17cb0
subq $0x8, %rsp
leaq 0x8(%rsp), %rax
leaq 0x18(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x5300
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x5090
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: ximdestroy
void ximdestroy(XIM xim, XPointer client, XPointer call) {
  xw.ime.xim = NULL;
  XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, ximinstantiate,
                                 NULL);
  XFree(xw.ime.spotlist);
}

// Assembly:
pushq %rax
movq $0x0, 0xb7d2(%rip) # 0x17ce8
movq 0xb783(%rip), %rdi      # 0x17ca0
leaq -0x358(%rip), %r8       # 0xc1cc
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x52f0
movq 0xb7c7(%rip), %rdi      # 0x17d00
popq %rax
jmp 0x5090
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: cresize
void cresize(int width, int height) {
  int col, row;

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

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

  // >>>>>>>>>>>>>>>>>>>> anysize
  // ==================== anysize
  // ==================== anysize
  // <<<<<<<<<<<<<<<<<<<< anysize

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

// Assembly:
testl %edi, %edi
je 0xc55a
movl %edi, 0xb84e(%rip)      # 0x17da8
testl %esi, %esi
je 0xc564
movl %esi, 0xb848(%rip)      # 0x17dac
pushq %rbp
pushq %rbx
pushq %rax
movl 0xb83b(%rip), %eax      # 0x17da8
addl $-0x4, %eax
cltd
idivl 0xb83d(%rip)            # 0x17db4
movl %eax, %ebx
movl 0xb82d(%rip), %eax      # 0x17dac
addl $-0x4, %eax
cltd
idivl 0xb827(%rip)            # 0x17db0
cmpl $0x2, %ebx
movl $0x1, %ebp
cmovll %ebp, %ebx
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0x6f9d
movl 0xb80b(%rip), %eax      # 0x17db4
imull %ebx, %eax
imull 0xb7fd(%rip), %ebp      # 0x17db0
movl %eax, 0xb7e7(%rip)      # 0x17da0
movl %ebp, 0xb7e5(%rip)      # 0x17da4
movq 0xb6da(%rip), %rdi      # 0x17ca0
movq 0xb6eb(%rip), %rsi      # 0x17cb8
callq 0x57b0
movq 0xb6c7(%rip), %rdi      # 0x17ca0
movq 0xb6d0(%rip), %rsi      # 0x17cb0
movl 0xb7c2(%rip), %edx      # 0x17da8
movl 0xb7c0(%rip), %ecx      # 0x17dac
movq 0xe8(%rdi), %rax
movslq 0xb78e(%rip), %r8       # 0x17d88
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x5830
movq %rax, 0xb6a9(%rip)      # 0x17cb8
movq 0xb6f2(%rip), %rdi      # 0x17d08
movq %rax, %rsi
callq 0x56a0
movl 0xb783(%rip), %r8d      # 0x17da8
movl 0xb780(%rip), %r9d      # 0x17dac
movq 0xb6d5(%rip), %rdi      # 0x17d08
testb $0x20, 0xb77e(%rip)     # 0x17db8
leaq 0x8e9b(%rip), %rax      # 0x154dc
leaq 0xb554(%rip), %rcx      # 0x17b9c
cmovneq %rax, %rcx
movl (%rcx), %esi
shlq $0x4, %rsi
addq 0xb54f(%rip), %rsi      # 0x17ba8
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53b0
movq 0xb657(%rip), %rdi      # 0x17cc0
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x5f00
movq %rax, 0xb644(%rip)      # 0x17cc0
movl 0xb71e(%rip), %edi      # 0x17da0
movl 0xb71c(%rip), %esi      # 0x17da4
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6e2d
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: brelease
void brelease(XEvent *e) {
  if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
    mousereport(e);
    return;
  }

  if (mouseaction(e, 1))
    return;

  // >>>>>>>>>>>>>>>>>>>> right-click-paste
  // ==================== right-click-paste
  // ==================== right-click-paste
  // <<<<<<<<<<<<<<<<<<<< right-click-paste

  if (e->xbutton.button == Button1)
    mousesel(e, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0xb3d7(%rip), %eax      # 0x17db8
testl $0xc018, %eax           # imm = 0xC018
je 0xc9f7
testb $0x1, 0x50(%rbx)
jne 0xc9f7
movq %rbx, %rdi
popq %rbx
jmp 0xd0d6
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd272
testl %eax, %eax
jne 0xca1c
cmpl $0x1, 0x54(%rbx)
jne 0xca1c
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0xd327
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: focus
void focus(XEvent *ev) {
  XFocusChangeEvent *e = &ev->xfocus;

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

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

// Assembly:
pushq %rax
cmpl $0x1, 0x28(%rdi)
jne 0xca47
popq %rax
retq
cmpl $0x9, (%rdi)
movq 0xb29f(%rip), %rdi      # 0x17cf0
jne 0xca7d
testq %rdi, %rdi
je 0xca5d
callq 0x5620
orb $0x2, 0xb354(%rip)      # 0x17db8
xorl %edi, %edi
callq 0xb08f
testb $0x20, 0xb347(%rip)     # 0x17db9
je 0xca45
leaq 0x2872(%rip), %rdi      # 0xf2ed
jmp 0xcaa5
testq %rdi, %rdi
je 0xca87
callq 0x53a0
movl 0xb32b(%rip), %eax      # 0x17db8
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0xb320(%rip)      # 0x17db8
btl $0xd, %eax
jae 0xca45
leaq 0x284c(%rip), %rdi      # 0xf2f1
movl $0x3, %esi
xorl %edx, %edx
popq %rax
jmp 0x6bbe
// File: /workspace/github_c_makefile_star2_O1/jaimecgomezz[P]st/x.c
// Function: zoomabs
void zoomabs(const Arg *arg) {
  xunloadfonts();
  xloadfonts(usedfont, arg->f);
  // >>>>>>>>>>>>>>>>>>>> font-2
  // ==================== font-2
  // ==================== font-2
  // <<<<<<<<<<<<<<<<<<<< font-2
  cresize(0, 0);
  redraw();
  xhints();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xae15(%rip), %eax      # 0x17e40
testl %eax, %eax
jle 0xd054
movq 0xac6a(%rip), %rdi      # 0x17ca0
movq 0xae0b(%rip), %rcx      # 0x17e48
decl %eax
movl %eax, 0xadfb(%rip)      # 0x17e40
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x50d0
jmp 0xd025
leaq 0xab5d(%rip), %rdi      # 0x17bb8
callq 0xd0a8
leaq 0xab89(%rip), %rdi      # 0x17bf0
callq 0xd0a8
leaq 0xabb5(%rip), %rdi      # 0x17c28
callq 0xd0a8
leaq 0xabe1(%rip), %rdi      # 0x17c60
callq 0xd0a8
movq 0xadcd(%rip), %rdi      # 0x17e58
cvtss2sd (%rbx), %xmm0
callq 0xbe46
xorl %edi, %edi
xorl %esi, %esi
callq 0xc550
callq 0x79af
popq %rbx
jmp 0xc1f5
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_line.c
// Function: get_line
int					get_line(char **line, t_minishell_meta *ms)
{
	static int	ret;
	static int	eof;
	int			tmp_errno;

	tmp_errno = errno;
	if (eof)
	{
		if (!previous_is_eof(&ret, &eof, line, ms))
			return (reset_errno_and_return(tmp_errno));
	}
	else
	{
		if (!current_line_handle(&ret, &eof, line, ms))
			return (reset_errno_and_return(tmp_errno));
	}
	if (errno != 1)
		errno = tmp_errno;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
callq 0x1040
movq %rax, %rbx
movl (%rax), %r15d
cmpb $0x1, 0x7e13(%rip)      # 0x90d8
jne 0x132c
movl %r15d, -0x2c(%rbp)
movq (%r14), %r15
leaq -0x38(%rbp), %r13
movq $0x0, (%r13)
xorl %edi, %edi
movq %r13, %rsi
callq 0x157c
movl %eax, 0x7dea(%rip)      # 0x90d4
leaq 0x7de3(%rip), %rdi      # 0x90d4
movq (%r13), %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x13f4
movq (%r13), %rsi
leaq 0x7dc9(%rip), %rdi      # 0x90d4
movq %r15, %rdx
movq %r12, %rcx
callq 0x142c
cmpl $0x1, (%rbx)
movq (%r13), %rdx
movq %r14, %rdi
jne 0x136b
movq %rdx, %rsi
callq 0x1545
jmp 0x1373
xorl %edi, %edi
movq %r14, %rsi
callq 0x157c
movl %eax, 0x7d98(%rip)      # 0x90d4
testl %eax, %eax
je 0x13a1
cmpl $0x1, %eax
je 0x1398
cmpl $-0x1, %eax
jne 0x13c7
movq %r14, %rdi
callq 0x17d4
movq 0x20(%r12), %rdi
callq 0x2af2
movq %r12, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
movq %r15, %rsi
callq 0x150a
movl 0x7d5b(%rip), %eax      # 0x90d4
cmpl $0x1, %eax
movl -0x2c(%rbp), %r15d
jne 0x1387
cmpl $0x2, (%rbx)
je 0x13b4
testl %eax, %eax
jle 0x1392
movb $0x0, 0x7d46(%rip)      # 0x90d8
testl %eax, %eax
jne 0x13d9
jmp 0x13b4
cmpl $0x2, (%rbx)
je 0x13ad
testl %eax, %eax
jne 0x13c7
movq (%r14), %rdi
callq 0x1802
testl %eax, %eax
je 0x13c7
movb $0x1, 0x7d24(%rip)      # 0x90d8
leaq 0x4c49(%rip), %rdi      # 0x6004
callq 0x4e10
movl $0x1, %eax
jmp 0x13db
leaq 0x7d06(%rip), %rdi      # 0x90d4
movq %r14, %rsi
movq %r12, %rdx
callq 0x14ad
xorl %eax, %eax
cmpl $0x1, (%rbx)
je 0x13e3
movl %r15d, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_line_utils.c
// Function: check_ret_lt_zero
void			check_ret_lt_zero(int *ret, char *new_line,\
char **line, t_minishell_meta *ms)
{
	(void)new_line;
	if (*ret < 0)
	{
		ft_free(line);
		free_tab(ms->env);
		free_tab(ms->export);
		free(ms);
		exit(0);
	}
}

// Assembly:
cmpl $0x0, (%rdi)
js 0x13fa
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rdi
callq 0x17d4
movq 0x20(%rbx), %rdi
callq 0x2af2
movq 0x28(%rbx), %rdi
callq 0x2af2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_line_utils.c
// Function: check_ret_eq_zero
void			check_ret_eq_zero(int *ret, char *new_line,\
char *bef_line, t_minishell_meta *ms)
{
	if (*ret == 0 && errno == 1 && !ft_strlen(new_line))
	{
		ft_free(&bef_line);
		ft_free(&new_line);
		ft_putendl_fd(" exit", 1);
		free_tab(ms->env);
		free_tab(ms->export);
		free(ms);
		exit(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, (%rdi)
jne 0x1460
movq %rcx, %rbx
movq %rsi, %r14
callq 0x1040
cmpl $0x1, (%rax)
jne 0x1460
movq %r14, %rdi
callq 0x1802
testl %eax, %eax
je 0x1469
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x17d4
leaq -0x20(%rbp), %rdi
callq 0x17d4
leaq 0x4b87(%rip), %rdi      # 0x6009
movl $0x1, %esi
callq 0x4dbc
movq 0x20(%rbx), %rdi
callq 0x2af2
movq 0x28(%rbx), %rdi
callq 0x2af2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_line_utils.c
// Function: check_ret_and_line
void			check_ret_and_line(int *ret, char **line,\
t_minishell_meta *ms)
{
	if (*ret == 0 && !ft_strlen(*line))
	{
		ft_free(line);
		ft_putendl_fd(" exit", 1);
		free_tab(ms->export);
		free_tab(ms->env);
		free(ms);
		exit(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, (%rdi)
jne 0x14cb
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x1802
testl %eax, %eax
je 0x14d0
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x17d4
leaq 0x4b2a(%rip), %rdi      # 0x6009
movl $0x1, %esi
callq 0x4dbc
movq 0x28(%rbx), %rdi
callq 0x2af2
movq 0x20(%rbx), %rdi
callq 0x2af2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_next_line_utils.c
// Function: ft_strdup
char			*ft_strdup(const char *s1)
{
	char	*copy;
	int		i;
	int		j;

	j = 0;
	i = 0;
	if (!(copy = (char *)malloc(sizeof(char) * (ft_strlen(s1) + 1))))
		return (0);
	while (s1[i])
	{
		copy[j] = s1[i];
		j++;
		i++;
	}
	copy[j] = '\0';
	return (copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rbx, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1830
sarq $0x20, %rdi
callq 0x1120
testq %rax, %rax
je 0x1864
movb (%rbx), %cl
testb %cl, %cl
je 0x1868
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%rbx,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x1852
movl %edx, %ecx
jmp 0x186a
xorl %eax, %eax
jmp 0x186e
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_next_line_utils.c
// Function: ft_strjoin
char			*ft_strjoin(char *s1, char *s2)
{
	int		i;
	int		j;
	char	*strj;

	i = -1;
	j = -1;
	if (s1 == NULL)
		return (NULL);
	if (s2 == NULL)
		return (ft_strdup(s1));
	strj = (char*)malloc((ft_strlen(s1) + ft_strlen(s2)) * sizeof(char) + 1);
	if (!strj)
		return (0);
	while (s1[++i] != '\0')
		strj[i] = s1[i];
	while (s2[++j] != '\0')
	{
		strj[i] = s2[j];
		i++;
	}
	strj[i] = '\0';
	return (strj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x191a
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1921
movabsq $-0x200000000, %rdi     # imm = 0xFFFFFFFE00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %r14, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x18ab
movq %rbx, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x18ba
sarq $0x20, %rdi
incq %rdi
callq 0x1120
xorl %ecx, %ecx
testq %rax, %rax
je 0x191a
movb (%r14), %dl
testb %dl, %dl
je 0x18f1
xorl %ecx, %ecx
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x18e2
movb (%rbx), %dl
testb %dl, %dl
je 0x1911
movl %ecx, %ecx
movq %rax, %rdi
addq %rcx, %rdi
xorl %esi, %esi
movb %dl, (%rdi,%rsi)
movb 0x1(%rbx,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x1901
addl %esi, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x191c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1818
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/get_next_line_utils.c
// Function: ft_stradd
char			*ft_stradd(char *str, char ch)
{
	char		*res;
	int			len;
	int			i;

	res = NULL;
	len = str ? ft_strlen(str) : 0;
	len = len + 2;
	res = (char*)malloc(sizeof(char) * (len));
	if (res == NULL)
		return (NULL);
	i = -1;
	while (str && str[++i])
		res[i] = str[i];
	res[len - 2] = ch;
	res[len - 1] = 0;
	ft_free(&str);
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
testq %rdi, %rdi
je 0x195a
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rbx, %rax
incl %r12d
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x194c
jmp 0x195d
xorl %r12d, %r12d
leal 0x2(%r12), %eax
movslq %eax, %rdi
callq 0x1120
testq %rax, %rax
je 0x199b
movq %rax, %r15
testq %rbx, %rbx
je 0x198c
xorl %eax, %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x19a0
movb %cl, (%r15,%rax)
incq %rax
testq %rbx, %rbx
jne 0x1979
movslq %r12d, %rax
movb %r14b, (%r15,%rax)
movb $0x0, 0x1(%r15,%rax)
jmp 0x19ba
xorl %r15d, %r15d
jmp 0x19ba
movslq %r12d, %rax
movb %r14b, (%r15,%rax)
movb $0x0, 0x1(%r15,%rax)
testq %rbx, %rbx
je 0x19ba
movq %rbx, %rdi
callq 0x1030
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/minishell.c
// Function: check_args
void			check_args(char **args)
{
	int i;

	i = 0;
	while (args[i])
	{
		ft_putstr_fd(args[i], 2);
		ft_putstr_fd("|\n", 2);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1a08
addq $0x8, %rbx
leaq 0x462a(%rip), %r14      # 0x600f
movl $0x2, %esi
callq 0x4e34
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e34
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x19e5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pvineet44[P]minishell/src/minishell.c
// Function: init_ms
void			init_ms(t_minishell_meta *ms)
{
	ms->arg_start = 0;
	ms->process_bit = 0;
	ms->arg = 0;
	ms->file_fd = -1;
	ms->out_fd = -1;
	ms->in_fd = -1;
	ms->multiline = 0;
	ms->piped_cmds = 0;
	ms->no_args = 0;
	ms->path = 0;
	ms->n = 0;
	set_path(ms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, 0x8(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x10(%rdi)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x40(%rdi)
movq $-0x1, 0x38(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x4c(%rdi)
movq %rax, 0x30(%rdi)
popq %rbp
jmp 0x4a9a