LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %r14
movq %rdi, 0x10(%rsp)
callq 0x5350
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incq %rdi
callq 0x5e2c
cmpb $0x0, (%r14)
movq %rax, %r15
je 0x9655
movq %rax, 0x8(%rsp)
movq %rax, %r15
addq $0x2, %r15
leaq 0x10(%rsp), %r14
leaq 0x4eeb(%rip), %r12      # 0xe4a0
movq %r14, %rdi
callq 0x9668
movzbl %al, %eax
movb (%rax,%r12), %bl
movq %r14, %rdi
callq 0x9668
movzbl %al, %eax
movb (%rax,%r12), %bpl
movq %r14, %rdi
callq 0x9668
movzbl %al, %eax
movb (%rax,%r12), %r13b
movq %r14, %rdi
callq 0x9668
cmpb $-0x1, %bl
je 0x9647
cmpb $-0x1, %bpl
je 0x9647
movzbl %al, %eax
movb (%rax,%r12), %al
shlb $0x2, %bl
movl %ebp, %ecx
shrb $0x4, %cl
andb $0x3, %cl
orb %bl, %cl
movb %cl, -0x2(%r15)
cmpb $-0x1, %r13b
je 0x964d
shlb $0x4, %bpl
movl %r13d, %ecx
shrb $0x2, %cl
andb $0xf, %cl
orb %bpl, %cl
movb %cl, -0x1(%r15)
cmpb $-0x1, %al
je 0x9650
shlb $0x6, %r13b
orb %r13b, %al
movb %al, (%r15)
movq 0x10(%rsp), %rax
addq $0x3, %r15
cmpb $0x0, (%rax)
jne 0x95b5
addq $-0x2, %r15
jmp 0x9650
decq %r15
movq 0x8(%rsp), %rax
movb $0x0, (%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9750
movl 0xc0b7(%rip), %r14d     # 0x157f8
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0x9753
xorl %r14d, %r14d
movl 0xc05b(%rip), %edx      # 0x157b4
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x76f9
movl 0xc084(%rip), %esi      # 0x157f8
movl %ebp, %edi
callq 0x61ab
movl 0xc077(%rip), %eax      # 0x157f8
subl %r14d, %eax
subl %ebx, %eax
jl 0x97bb
movslq %ebx, %rdx
movslq %r14d, %rcx
movq 0xc023(%rip), %rsi      # 0x157b8
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 0x97a4
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x9df7
// File: /workspace/github_c_makefile_star2_O3/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 %esi, %eax
movl %edi, %ebx
movl 0xc01e(%rip), %esi      # 0x157f8
testl %eax, %eax
js 0x97f0
movl %esi, %r14d
subl %ebx, %r14d
incl %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
jmp 0x97f3
xorl %r14d, %r14d
subl %r14d, %esi
movl %ebx, %edi
callq 0x61ab
movl 0xbff5(%rip), %ecx      # 0x157f8
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0xbfa4(%rip), %edx      # 0x157b4
decl %edx
xorl %edi, %edi
callq 0x76f9
movslq 0xbfd8(%rip), %rax      # 0x157f8
leal (%r14,%rbx), %ecx
cmpl %ecx, %eax
jl 0x985e
movslq %r14d, %rdi
movslq %ecx, %rcx
movq 0xbf83(%rip), %rdx      # 0x157b8
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 0x9842
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9df7
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %eax
movslq 0xbbf6(%rip), %rdi      # 0x157e0
movl 0xbbc4(%rip), %ecx      # 0x157b4
movl %ecx, %edx
subl %edi, %edx
cmpl %eax, %edx
cmovgel %eax, %edx
xorl %ebx, %ebx
testl %eax, %eax
cmovnsl %edx, %ebx
leal (%rdi,%rbx), %eax
subl %eax, %ecx
movq 0xbbac(%rip), %rdx      # 0x157b8
movslq 0xbbd1(%rip), %rsi      # 0x157e4
movq (%rdx,%rsi,8), %rdx
shlq $0x4, %rdi
addq %rdx, %rdi
movslq %eax, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
movslq %ecx, %rdx
shlq $0x4, %rdx
callq 0x54e0
movl 0xbb7a(%rip), %edx      # 0x157b4
movl %edx, %edi
subl %ebx, %edi
movl 0xbba0(%rip), %ecx      # 0x157e4
decl %edx
movl %ecx, %esi
popq %rbx
jmp 0x76f9
// File: /workspace/github_c_makefile_star2_O3/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, 0xb99e(%rip)     # 0x1579c
je 0x9e9a
movl %esi, %eax
movl %edi, %ecx
movl 0xb982(%rip), %edi      # 0x15790
cmpl %ecx, %edi
setge %sil
movl 0xb9de(%rip), %edx      # 0x157f8
cmpl %edx, %edi
setle %r8b
andb %sil, %r8b
movl 0xb96f(%rip), %esi      # 0x15798
cmpl %ecx, %esi
setl %cl
cmpl %edx, %esi
setg %r9b
orb %cl, %r9b
cmpb %r9b, %r8b
je 0x9e81
testb %r8b, %r8b
je 0x9e9a
movl 0xb959(%rip), %ecx      # 0x157a0
addl %eax, %ecx
movl %ecx, 0xb951(%rip)      # 0x157a0
addl 0xb953(%rip), %eax      # 0x157a8
movl %eax, 0xb94d(%rip)      # 0x157a8
movl 0xb992(%rip), %r8d      # 0x157f4
cmpl %r8d, %ecx
jl 0x9e81
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 0x9e9b
movl $0x0, 0xb8f5(%rip)      # 0x15780
movl $0xffffffff, 0xb907(%rip) # imm = 0xFFFFFFFF
jmp 0x61ab
retq
jmp 0x60af
// File: /workspace/github_c_makefile_star2_O3/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 0xde7a(%rip), %rdi      # 0x17e08
callq 0x5320
movq $0x0, 0xde6a(%rip) # 0x17e08
movq 0xde5b(%rip), %rdi      # 0x17e00
testq %rdi, %rdi
je 0x9fe4
callq 0x5f1a
movq %rax, 0xde52(%rip)      # 0x17e08
movq 0xdcd3(%rip), %rdi      # 0x17c90
leaq 0x4c13(%rip), %rsi      # 0xebd7
xorl %edx, %edx
callq 0x5720
movq 0xdcbe(%rip), %rdi      # 0x17c90
movq 0xdcc7(%rip), %rdx      # 0x17ca0
movq %rax, %rsi
xorl %ecx, %ecx
popq %rax
jmp 0x55f0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa04d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xde00(%rip), %rdi      # 0x17e00
callq 0x5320
movq %r14, 0xddf4(%rip)      # 0x17e00
movq 0xdc7d(%rip), %rdi      # 0x17c90
movq 0xdc86(%rip), %rdx      # 0x17ca0
movl $0x1, %esi
movq %rbx, %rcx
callq 0x55f0
movq 0xdc62(%rip), %rdi      # 0x17c90
movl $0x1, %esi
callq 0x5870
cmpq 0xdc61(%rip), %rax      # 0x17ca0
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
jne 0x6080
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa20e
leal -0x10(%rdi), %r9d
cmpl $0xef, %r9d
ja 0xa200
cmpl $0xe7, %edi
ja 0xa229
movzbl %r9b, %ecx
imull $0x39, %ecx, %eax
shrl $0xb, %eax
imull $0x2828, %eax, %eax     # imm = 0x2828
movl $0x3737, %esi           # imm = 0x3737
addl %esi, %eax
xorl %edx, %edx
cmpl $0x24, %r9d
cmovbl %edx, %eax
imull $0xab, %ecx, %r9d
shrl $0xa, %r9d
imull $0x2b, %r9d, %edi
shrl $0x7, %edi
andl $-0x2, %edi
leal (%rdi,%rdi,2), %edi
movl %r9d, %r10d
subb %dil, %r10b
movzbl %r10b, %r10d
imull $0x2828, %r10d, %edi    # imm = 0x2828
addl %esi, %edi
testb %r10b, %r10b
cmovel %edx, %edi
addl %r9d, %r9d
leal (%r9,%r9,2), %r9d
subb %r9b, %cl
movzbl %cl, %ecx
imull $0x2828, %ecx, %r9d     # imm = 0x2828
addl %esi, %r9d
testb %cl, %cl
cmovel %edx, %r9d
jmp 0xa239
movslq %edi, %rax
leaq 0x8826(%rip), %rcx      # 0x12a30
movq (%rcx,%rax,8), %rcx
movq 0xda7b(%rip), %rdi      # 0x17c90
movq 0xdae4(%rip), %rsi      # 0x17d00
movq 0xda75(%rip), %rdx      # 0x17c98
popq %rax
jmp 0x54d0
imull $0xa0a, %edi, %eax      # imm = 0xA0A
addl $0xffffeef8, %eax       # imm = 0xFFFFEEF8
movl %eax, %edi
movl %eax, %r9d
movq %rsp, %rcx
movw %ax, (%rcx)
movw %di, 0x2(%rcx)
movw %r9w, 0x4(%rcx)
movq 0xda41(%rip), %rdi      # 0x17c90
movq 0xdaaa(%rip), %rsi      # 0x17d00
movq 0xda3b(%rip), %rdx      # 0x17c98
callq 0x56c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
jne 0xa5d9
movq 0xd7d7(%rip), %rdi      # 0x17db0
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0xd6a3(%rip), %rdi      # 0x17c90
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %r8
callq 0x5400
movq 0xd685(%rip), %rdi      # 0x17c90
movq 0xd68e(%rip), %rsi      # 0x17ca0
movq %rbx, %rdx
callq 0x53c0
movq 0xd66f(%rip), %rdi      # 0x17c90
movq 0xd678(%rip), %rsi      # 0x17ca0
movq 0xd699(%rip), %rcx      # 0x17cc8
movq %rbx, %rdx
callq 0x5420
movq (%rbx), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xca48(%rip), %rdi      # 0x17ce0
testq %rdi, %rdi
je 0xb2d8
imull 0xcb00(%rip), %eax      # 0x17da4
addl $0x2, %eax
movw %ax, 0xca3a(%rip)       # 0x17ce8
incl %esi
imull 0xcae9(%rip), %esi      # 0x17da0
addl $0x2, %esi
movw %si, 0xca29(%rip)       # 0x17cea
movq 0xca28(%rip), %rdx      # 0x17cf0
leaq 0x38e9(%rip), %rsi      # 0xebb8
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x5250
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6e3b(%rip), %xmm0     # 0x13240
movaps %xmm0, 0x10(%rsp)
movups 0x6e3f(%rip), %xmm0     # 0x13250
movaps %xmm0, (%rsp)
movq 0xb874(%rip), %rdi      # 0x17c90
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5680
movq %rax, 0xb8a8(%rip)      # 0x17cd8
testq %rax, %rax
je 0xc4cb
leaq 0x2a79(%rip), %rsi      # 0xeeb9
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x55a0
testq %rax, %rax
jne 0xc4d3
leaq 0x2a9c(%rip), %rsi      # 0xeef9
leaq 0xb884(%rip), %rdx      # 0x17ce8
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x56b0
movq %rax, 0xb87a(%rip)      # 0x17cf0
movl $0x1, %ebx
cmpq $0x0, 0xb85d(%rip)      # 0x17ce0
jne 0xc4cb
movq 0xb84c(%rip), %rdi      # 0x17cd8
movq 0xb80d(%rip), %r8       # 0x17ca0
movq %rsp, %r10
leaq 0x2a69(%rip), %rsi      # 0xef06
leaq 0x2a6d(%rip), %rcx      # 0xef11
leaq 0x2a0e(%rip), %r9       # 0xeeb9
movl $0x408, %edx            # imm = 0x408
xorl %eax, %eax
pushq $0x0
pushq %r10
callq 0x5030
addq $0x10, %rsp
movq %rax, 0xb81a(%rip)      # 0x17ce0
testq %rax, %rax
je 0xc4dd
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x5c66
jmp 0xc456
callq 0x5c88
jmp 0xc4cb
// File: /workspace/github_c_makefile_star2_O3/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 0xb8c7(%rip), %rax      # 0x17de0
testq %rax, %rax
movq 0x8f9d(%rip), %rcx      # 0x154c0
cmoveq %rcx, %rax
movq 0xb892(%rip), %rdx      # 0x17dc0
testq %rdx, %rdx
cmoveq %rcx, %rdx
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x5790
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0xb825(%rip), %eax      # 0x17d9c
movl %eax, 0x14(%rbx)
movl 0xb818(%rip), %ecx      # 0x17d98
movl %ecx, 0x10(%rbx)
movl 0xb817(%rip), %edx      # 0x17da0
movl %edx, 0x2c(%rbx)
movl 0xb812(%rip), %esi      # 0x17da4
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, 0xb7c6(%rip)      # 0x17d7c
je 0xc5d2
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl $0x379, %ecx            # imm = 0x379
jmp 0xc5d7
movl $0x359, %ecx            # imm = 0x359
movl 0xb7ab(%rip), %eax      # 0x17d88
testb $0x3, %al
je 0xc602
movq %rcx, (%rbx)
movq 0xb795(%rip), %rcx      # 0x17d80
movq %rcx, 0x8(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x2da0(%rip), %rcx      # 0xf39c
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0xb687(%rip), %rdi      # 0x17c90
movq 0xb690(%rip), %rsi      # 0x17ca0
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x5300
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x5090
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xb4af(%rip) # 0x17cd8
movq 0xb460(%rip), %rdi      # 0x17c90
leaq -0x353(%rip), %r8       # 0xc4e4
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x52f0
movq 0xb4a4(%rip), %rdi      # 0x17cf0
popq %rax
jmp 0x5090
// File: /workspace/github_c_makefile_star2_O3/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 0xc86d
movl %edi, 0xb52b(%rip)      # 0x17d98
testl %esi, %esi
je 0xc879
movl %esi, 0xb525(%rip)      # 0x17d9c
jmp 0xc87f
movl 0xb51d(%rip), %esi      # 0x17d9c
pushq %rbp
pushq %rbx
pushq %rax
movl 0xb510(%rip), %eax      # 0x17d98
addl $-0x4, %eax
cltd
idivl 0xb512(%rip)            # 0x17da4
movl %eax, %ebx
addl $-0x4, %esi
movl %esi, %eax
cltd
idivl 0xb500(%rip)            # 0x17da0
cmpl $0x2, %ebx
movl $0x1, %ebp
cmovll %ebp, %ebx
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0x70bd
movl 0xb4e4(%rip), %eax      # 0x17da4
imull %ebx, %eax
imull 0xb4d6(%rip), %ebp      # 0x17da0
movl %eax, 0xb4c0(%rip)      # 0x17d90
movl %ebp, 0xb4be(%rip)      # 0x17d94
movq 0xb3b3(%rip), %rdi      # 0x17c90
movq 0xb3c4(%rip), %rsi      # 0x17ca8
callq 0x57a0
movq 0xb3a0(%rip), %rdi      # 0x17c90
movq 0xb3a9(%rip), %rsi      # 0x17ca0
movl 0xb49b(%rip), %edx      # 0x17d98
movl 0xb499(%rip), %ecx      # 0x17d9c
movq 0xe8(%rdi), %rax
movslq 0xb467(%rip), %r8       # 0x17d78
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x5820
movq %rax, 0xb382(%rip)      # 0x17ca8
movq 0xb3cb(%rip), %rdi      # 0x17cf8
movq %rax, %rsi
callq 0x5690
movl 0xb45c(%rip), %r8d      # 0x17d98
movl 0xb459(%rip), %r9d      # 0x17d9c
movq 0xb3ae(%rip), %rdi      # 0x17cf8
testb $0x20, 0xb457(%rip)     # 0x17da8
leaq 0x8b74(%rip), %rax      # 0x154cc
leaq 0xb22d(%rip), %rcx      # 0x17b8c
cmovneq %rax, %rcx
movl (%rcx), %esi
shlq $0x4, %rsi
addq 0xb228(%rip), %rsi      # 0x17b98
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53b0
movq 0xb330(%rip), %rdi      # 0x17cb0
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x5ef0
movq %rax, 0xb31d(%rip)      # 0x17cb0
movl 0xb3f7(%rip), %edi      # 0x17d90
movl 0xb3f5(%rip), %esi      # 0x17d94
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6f44
// File: /workspace/github_c_makefile_star2_O3/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 0xb0c1(%rip), %eax      # 0x17da8
testl $0xc018, %eax           # imm = 0xC018
setne %al
movl 0x50(%rdi), %edi
testb $0x1, %dil
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xcd09
movq %rbx, %rdi
popq %rbx
jmp 0xd3e2
movl 0x54(%rbx), %esi
movl $0x1, %edx
callq 0xd57e
testl %eax, %eax
jne 0xcd2e
cmpl $0x1, 0x54(%rbx)
jne 0xcd2e
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0xd625
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcd59
popq %rax
retq
cmpl $0x9, (%rdi)
movq 0xaf7d(%rip), %rdi      # 0x17ce0
jne 0xcd8f
testq %rdi, %rdi
je 0xcd6f
callq 0x5620
orb $0x2, 0xb032(%rip)      # 0x17da8
xorl %edi, %edi
callq 0xb361
testb $0x20, 0xb025(%rip)     # 0x17da9
je 0xcd57
leaq 0x257c(%rip), %rdi      # 0xf309
jmp 0xcdb7
testq %rdi, %rdi
je 0xcd99
callq 0x53a0
movl 0xb009(%rip), %eax      # 0x17da8
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0xaffe(%rip)      # 0x17da8
btl $0xd, %eax
jae 0xcd57
leaq 0x2556(%rip), %rdi      # 0xf30d
movl $0x3, %esi
xorl %edx, %edx
popq %rax
jmp 0x6cab
// File: /workspace/github_c_makefile_star2_O3/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 0xaaf9(%rip), %eax      # 0x17e30
testl %eax, %eax
jle 0xd360
movq 0xa94e(%rip), %rdi      # 0x17c90
movq 0xaaef(%rip), %rcx      # 0x17e38
decl %eax
movl %eax, 0xaadf(%rip)      # 0x17e30
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x50d0
jmp 0xd331
leaq 0xa841(%rip), %rdi      # 0x17ba8
callq 0xd3b4
leaq 0xa86d(%rip), %rdi      # 0x17be0
callq 0xd3b4
leaq 0xa899(%rip), %rdi      # 0x17c18
callq 0xd3b4
leaq 0xa8c5(%rip), %rdi      # 0x17c50
callq 0xd3b4
movq 0xaab1(%rip), %rdi      # 0x17e48
cvtss2sd (%rbx), %xmm0
callq 0xc167
xorl %edi, %edi
xorl %esi, %esi
callq 0xc863
callq 0x7bb6
popq %rbx
jmp 0xc50d
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, %r14
callq 0x1040
movq %rax, %rbx
movl (%rax), %r12d
cmpb $0x1, 0x7e13(%rip)      # 0x90d8
jne 0x132c
movl %r12d, -0x2c(%rbp)
movq (%r14), %r12
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 %r15, %rcx
callq 0x13f0
movq (%r13), %rsi
leaq 0x7dc9(%rip), %rdi      # 0x90d4
movq %r12, %rdx
movq %r15, %rcx
callq 0x1428
cmpl $0x1, (%rbx)
movq (%r13), %rdx
movq %r14, %rdi
jne 0x136a
movq %rdx, %rsi
callq 0x1541
jmp 0x1372
xorl %edi, %edi
movq %r14, %rsi
callq 0x157c
movl %eax, 0x7d98(%rip)      # 0x90d4
testl %eax, %eax
je 0x13b0
cmpl $0x1, %eax
je 0x1395
cmpl $-0x1, %eax
jne 0x139a
movq %r14, %rdi
callq 0x17b0
movq 0x20(%r15), %rdi
callq 0x2aa2
movq %r15, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
movq %r12, %rsi
callq 0x1506
movl 0x7d5c(%rip), %eax      # 0x90d4
cmpl $0x1, %eax
movl -0x2c(%rbp), %r12d
jne 0x1388
cmpl $0x2, (%rbx)
jne 0x138c
jmp 0x13c3
testl %eax, %eax
jle 0x13eb
movb $0x0, 0x7d45(%rip)      # 0x90d8
jmp 0x13ac
cmpl $0x2, (%rbx)
je 0x13bc
leaq 0x7d33(%rip), %rdi      # 0x90d4
movq %r14, %rsi
movq %r15, %rdx
callq 0x14a9
xorl %eax, %eax
jmp 0x13d4
movq (%r14), %rdi
callq 0x17de
testl %eax, %eax
je 0x139a
movb $0x1, 0x7d15(%rip)      # 0x90d8
leaq 0x4c3a(%rip), %rdi      # 0x6004
callq 0x4de8
movl $0x1, %eax
cmpl $0x1, (%rbx)
je 0x13dc
movl %r12d, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jne 0x13ac
jmp 0x13c3
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x13f6
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rdi
callq 0x17b0
movq 0x20(%rbx), %rdi
callq 0x2aa2
movq 0x28(%rbx), %rdi
callq 0x2aa2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O3/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 0x145c
movq %rcx, %rbx
movq %rsi, %r14
callq 0x1040
cmpl $0x1, (%rax)
jne 0x145c
movq %r14, %rdi
callq 0x17de
testl %eax, %eax
je 0x1465
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x17b0
leaq -0x20(%rbp), %rdi
callq 0x17b0
leaq 0x4b8b(%rip), %rdi      # 0x6009
movl $0x1, %esi
callq 0x4d94
movq 0x20(%rbx), %rdi
callq 0x2aa2
movq 0x28(%rbx), %rdi
callq 0x2aa2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O3/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 0x14c7
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x17de
testl %eax, %eax
je 0x14cc
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x17b0
leaq 0x4b2e(%rip), %rdi      # 0x6009
movl $0x1, %esi
callq 0x4d94
movq 0x28(%rbx), %rdi
callq 0x2aa2
movq 0x20(%rbx), %rdi
callq 0x2aa2
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O3/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 0x180c
sarq $0x20, %rdi
callq 0x1120
testq %rax, %rax
je 0x1846
movb (%rbx), %cl
testb %cl, %cl
je 0x1840
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb 0x1(%rbx,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x182e
movl %edx, %ecx
jmp 0x1842
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18f2
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x18f9
movabsq $-0x200000000, %rdi     # imm = 0xFFFFFFFE00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %r14, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1883
movq %rbx, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1892
sarq $0x20, %rdi
incq %rdi
callq 0x1120
xorl %ecx, %ecx
testq %rax, %rax
je 0x18f2
movb (%r14), %dl
testb %dl, %dl
je 0x18c9
xorl %ecx, %ecx
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x18ba
movb (%rbx), %dl
testb %dl, %dl
je 0x18e9
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 0x18d9
addl %esi, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x18f4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x17f4
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movq %rdi, %r14
testq %rdi, %rdi
je 0x1931
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %r14, %rax
incl %r12d
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x1923
jmp 0x1934
xorl %r12d, %r12d
leal 0x2(%r12), %eax
movslq %eax, %rdi
callq 0x1120
movq %rax, %r15
testq %rax, %rax
je 0x198b
testq %r14, %r14
je 0x197e
movb (%r14), %al
testb %al, %al
je 0x1967
xorl %ecx, %ecx
movb %al, (%r15,%rcx)
movb 0x1(%r14,%rcx), %al
incq %rcx
testb %al, %al
jne 0x1957
movslq %r12d, %rax
movb %bl, (%r15,%rax)
movb $0x0, 0x1(%r15,%rax)
movq %r14, %rdi
callq 0x1030
jmp 0x198b
movslq %r12d, %rax
movb %bl, (%r15,%rax)
movb $0x0, 0x1(%r15,%rax)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x19d8
addq $0x8, %rbx
leaq 0x465a(%rip), %r14      # 0x600f
movl $0x2, %esi
callq 0x4e0c
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e0c
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x19b5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/minishell.c
// Function: invoke_minishell
void			invoke_minishell(t_minishell_meta *ms, char *line)
{
	char	*tmp;

	tmp = ft_strtrim(line, "\t \n\v\f\r");
	ft_free(&line);
	line = ft_strdup(tmp);
	ft_free(&tmp);
	init_ms(ms);
	line = parse(ms, line);
	if (!ms->multiline && line[0] != '\0')
	{
		process(ms, line);
		free_all(ms, line);
	}
	else
		free_all(ms, line);
	write(STDOUT_FILENO, SHELL_BANNER, 15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %rsi, (%r14)
leaq 0x45df(%rip), %rsi      # 0x6012
movq %rax, %rdi
callq 0x50dc
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %rax, (%r12)
movq %r14, %rdi
callq 0x17b0
movq %r15, %rdi
callq 0x17f4
movq %rax, (%r14)
movq %r12, %rdi
callq 0x17b0
xorl %r15d, %r15d
movl %r15d, 0x8(%rbx)
movl %r15d, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x40(%rbx)
movq $-0x1, 0x38(%rbx)
movq %r15, 0x58(%rbx)
movq %r15, 0x4c(%rbx)
movq %r15, 0x30(%rbx)
movq %rbx, %rdi
callq 0x4a7c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2f10
movq %rax, %rsi
movq %rax, (%r14)
cmpl %r15d, 0x44(%rbx)
jne 0x1abd
cmpb $0x0, (%rsi)
je 0x1abd
movq %rbx, %rdi
callq 0x3e2a
movq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x2b45
leaq 0x454d(%rip), %rsi      # 0x6019
movl $0xf, %edx
movl $0x1, %edi
callq 0x1050
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/minishell.c
// Function: is_spaces_only
int				is_spaces_only(char *line)
{
	int i;
	int len;

	i = 0;
	len = ft_strlen(line);
	while (i < len)
	{
		if (!ft_isspace(line[i]))
			return (0);
		i++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x17de
movl $0x1, %ebx
testl %eax, %eax
jle 0x1b24
movl %eax, %r15d
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
callq 0x4c68
testl %eax, %eax
je 0x1b22
incq %r12
cmpq %r12, %r15
jne 0x1b0a
jmp 0x1b24
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/minishell.c
// Function: main
int				main(int ac, char **av, char **env)
{
	char				*line;
	t_minishell_meta	*ms;

	(void)ac;
	(void)av;
	line = NULL;
	signal(SIGINT, sig_int_handler);
	signal(SIGQUIT, sig_quit_handler);
	if (!(ms = malloc(sizeof(t_minishell_meta))))
		return (1);
	set_env_export(ms, env);
	while (1)
	{
		if (get_line(&line, ms))
			continue ;
		if ((line[0] == '\0' || is_spaces_only(line)) && ft_free(&line))
		{
			write(STDOUT_FILENO, SHELL_BANNER, 15);
			continue ;
		}
		invoke_minishell(ms, line);
	}
	free_tab(ms->path);
	free(ms);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq $0x0, -0x20(%rbp)
leaq 0x239d(%rip), %rsi      # 0x3ee8
movl $0x2, %edi
callq 0x1100
leaq 0x2455(%rip), %rsi      # 0x3fb1
movl $0x3, %edi
callq 0x1100
movl $0x60, %edi
callq 0x1120
testq %rax, %rax
je 0x1bdd
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4ac1
leaq -0x20(%rbp), %r14
leaq 0x448b(%rip), %r15      # 0x6019
movq %r14, %rdi
movq %rbx, %rsi
callq 0x129c
testl %eax, %eax
jne 0x1b8e
movq -0x20(%rbp), %rdi
cmpb $0x0, (%rdi)
je 0x1baf
callq 0x1ae8
testl %eax, %eax
je 0x1bcf
movq %r14, %rdi
callq 0x17b0
testl %eax, %eax
je 0x1bcf
movl $0xf, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1050
jmp 0x1b8e
movq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x1a10
jmp 0x1b8e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_cd.c
// Function: print_home_not_set
void	print_home_not_set(void)
{
	errno = 1;
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(": cd: ", STDERR_FILENO);
	ft_putstr_fd("HOME not set\n", STDERR_FILENO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1040
movl $0x1, (%rax)
leaq 0x4423(%rip), %rdi      # 0x6029
movl $0x2, %esi
callq 0x4e0c
leaq 0x441c(%rip), %rdi      # 0x6033
movl $0x2, %esi
callq 0x4e0c
leaq 0x4412(%rip), %rdi      # 0x603a
movl $0x2, %esi
popq %rbp
jmp 0x4e0c
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_cd.c
// Function: ms_cd
void	ms_cd(char *path, t_minishell_meta *ms)
{
	int ret;

	errno = 0;
	if ((path == NULL) || ft_strcmp(path, "") == 0)
	{
		substitute_value("$HOME", 0, ms);
		if ((ret = chdir(ms->arg)) == -1)
			print_home_not_set();
		ft_free(&ms->arg);
		return ;
	}
	ret = chdir(path);
	if (ret < 0)
	{
		errno = 1;
		no_file_or_directory("cd", path);
	}
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1040
movl $0x0, (%rax)
testq %r14, %r14
je 0x1c80
movq %rax, %r15
leaq 0x43ab(%rip), %rsi      # 0x6008
movq %r14, %rdi
callq 0x506c
testl %eax, %eax
je 0x1c80
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
js 0x1cba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43c1(%rip), %rdi      # 0x6048
xorl %esi, %esi
movq %rbx, %rdx
callq 0x439a
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
callq 0x1060
cmpl $-0x1, %eax
jne 0x1ca8
callq 0x1bf0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x17b0
movl $0x1, (%r15)
leaq 0x4386(%rip), %rdi      # 0x604e
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x47d0
nop
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_ce_path.c
// Function: check_and_execute_path
int				check_and_execute_path(t_minishell_meta *ms, int i)
{
	char			*path;
	int				j;
	struct stat		buffer;
	char			*tmp_cmd;

	j = 0;
	if (ms->path == 0)
		return (no_path_set(ms->piped_cmds->cmds[i]));
	while (ms->path[j] != NULL)
	{
		tmp_cmd = ft_strjoin(ms->path[j], "/");
		path = ft_strjoin(tmp_cmd, ms->piped_cmds->cmds[i]);
		if (lstat(path, &buffer) == 0)
		{
			ms_execute(path, ms->piped_cmds->args1[i], ms->env);
			ft_free(&tmp_cmd);
			ft_free(&path);
			return (1);
		}
		ft_free(&path);
		ft_free(&tmp_cmd);
		j++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1d97
movq (%rax), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x1df0
movslq %esi, %r13
movl $0x8, %r15d
leaq -0xc8(%rbp), %r12
leaq -0x30(%rbp), %rbx
leaq 0x430f(%rip), %rsi      # 0x6051
callq 0x184d
movq %rax, -0x30(%rbp)
movq 0x58(%r14), %rcx
movq (%rcx), %rcx
movq (%rcx,%r13,8), %rsi
movq %rax, %rdi
callq 0x184d
movq %rax, -0x38(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x10e0
testl %eax, %eax
je 0x1dbe
leaq -0x38(%rbp), %rdi
callq 0x17b0
movq %rbx, %rdi
callq 0x17b0
movq 0x30(%r14), %rax
movq (%rax,%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x1d3b
xorl %eax, %eax
jmp 0x1df0
movq 0x58(%r14), %rax
movq (%rax), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x47d0
callq 0x1040
movl $0x7f, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1df0
leaq -0x38(%rbp), %rbx
movq (%rbx), %rdi
movq 0x20(%r14), %rdx
movq 0x58(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax,%r13,8), %rsi
callq 0x20f9
leaq -0x30(%rbp), %rdi
callq 0x17b0
movq %rbx, %rdi
callq 0x17b0
movl $0x1, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_echo.c
// Function: ms_echo
void				ms_echo(char **args)
{
	int i;
	int c;

	i = 0;
	c = 0;
	if (args[0] == NULL)
		c = 0;
	else if (ft_strcmp(args[i], "-n") == 0)
	{
		c = 1;
		i++;
	}
	while (args[i])
	{
		ft_putstr_fd(args[i], STDOUT_FILENO);
		if (args[i + 1])
			ft_putstr_fd(" ", STDOUT_FILENO);
		i++;
	}
	if (c != 1)
		ft_putstr_fd("\n", STDOUT_FILENO);
	errno = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1ec6
leaq 0x41e7(%rip), %rsi      # 0x6053
callq 0x506c
movl %eax, %ebx
xorl %eax, %eax
testl %ebx, %ebx
sete %al
movq (%r14,%rax,8), %rdi
testq %rdi, %rdi
je 0x1ec2
xorl %eax, %eax
testl %ebx, %ebx
sete %al
leaq (%r14,%rax,8), %r15
addq $0x8, %r15
leaq 0x4283(%rip), %r14      # 0x611c
movl $0x1, %esi
callq 0x4e0c
cmpq $0x0, (%r15)
je 0x1ec2
movq %r14, %rdi
movl $0x1, %esi
callq 0x4e0c
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x1e99
testl %ebx, %ebx
je 0x1ed7
leaq 0x42c2(%rip), %rdi      # 0x618f
movl $0x1, %esi
callq 0x4e0c
callq 0x1040
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_env.c
// Function: ms_env
void	ms_env(char **env)
{
	int		i;

	i = 0;
	errno = 0;
	while (env[i])
	{
		ft_putendl_fd(env[i], STDOUT_FILENO);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1040
movl $0x0, (%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f26
addq $0x8, %rbx
movl $0x1, %esi
callq 0x4d94
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x1f10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_execute.c
// Function: write_permission_denied
void			write_permission_denied(char *path)
{
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	ft_putstr_fd(path, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	ft_putstr_fd("Permission denied\n", STDERR_FILENO);
	errno = 126;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40e8(%rip), %rdi      # 0x6029
movl $0x2, %esi
callq 0x4e0c
leaq 0x40e5(%rip), %r14      # 0x6037
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e0c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4e0c
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e0c
leaq 0x40d6(%rip), %rdi      # 0x6056
movl $0x2, %esi
callq 0x4e0c
callq 0x1040
movl $0x7e, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_execute.c
// Function: fork_process
void			fork_process(char *path, char **av, char **env)
{
	pid_t	pid;
	int		x;

	x = 1;
	pid = fork();
	if (1)
	{
		signal(SIGINT, proc_signal_handler);
		signal(SIGQUIT, proc_sigquit_handler);
	}
	if (pid == 0)
		x = execve(path, av, env);
	if (x == -1)
	{
		write_error(path);
		exit(127);
		return ;
	}
	wait(&errno);
	errno = errno / 255;
	free_tab(av);
	signal(SIGINT, sig_int_handler);
	signal(SIGQUIT, sig_quit_handler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1170
movl %eax, %r12d
leaq 0x1f46(%rip), %rsi      # 0x3f3d
movl $0x2, %edi
callq 0x1100
leaq 0x1f7c(%rip), %rsi      # 0x3f84
movl $0x3, %edi
callq 0x1100
testl %r12d, %r12d
jne 0x202a
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10f0
cmpl $-0x1, %eax
je 0x2089
callq 0x1040
movq %rax, %r14
movq %rax, %rdi
callq 0x1160
movslq (%r14), %rax
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x7, %ecx
addl %eax, %ecx
movl %ecx, (%r14)
movq %rbx, %rdi
callq 0x2aa2
leaq 0x1e82(%rip), %rsi      # 0x3ee8
movl $0x2, %edi
callq 0x1100
leaq 0x1f3a(%rip), %rsi      # 0x3fb1
movl $0x3, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1100
movq %r14, %rdi
callq 0x209b
movl $0x7f, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_execute.c
// Function: write_error
static void		write_error(char *path)
{
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	ft_putstr_fd(path, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	ft_putstr_fd("No such file or directory\n", STDERR_FILENO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3f7d(%rip), %rdi      # 0x6029
movl $0x2, %esi
callq 0x4e0c
leaq 0x3f7a(%rip), %r14      # 0x6037
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e0c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4e0c
movq %r14, %rdi
movl $0x2, %esi
callq 0x4e0c
leaq 0x3f7e(%rip), %rdi      # 0x6069
movl $0x2, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4e0c
// File: /workspace/github_c_makefile_star2_O3/pvineet44[P]minishell/src/ms_execute.c
// Function: ms_execute
void			ms_execute(char *path, char **args, char **env)
{
	int		i;
	int		len;
	char	**av;

	i = 0;
	errno = 0;
	len = ft_tablen(args);
	if (check_file_permission(path) == 0)
		return ;
	av = (char**)malloc(sizeof(char*) * (len + 2));
	if (av == NULL)
		ms_exit(NULL, NULL, 0);
	av[0] = ft_strdup(path);
	while (args[i] != 0 && len != 0)
	{
		av[i + 1] = ft_strdup(args[i]);
		i++;
	}
	av[i + 1] = 0;
	fork_process(path, av, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1040
movl $0x0, (%rax)
movq %r15, %rdi
callq 0x1e2f
movl %eax, %r13d
movq %r14, %rdi
callq 0x37a8
testl %eax, %eax
je 0x2197
movslq %r13d, %rax
leaq 0x10(,%rax,8), %rdi
callq 0x1120
movq %rax, %r12
testq %rax, %rax
jne 0x2155
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21fe
movq %r14, %rdi
callq 0x17f4
movq %rax, (%r12)
testl %r13d, %r13d
setne %al
movq (%r15), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x21a6
xorl %r13d, %r13d
callq 0x17f4
leaq 0x1(%r13), %rcx
movq %rax, 0x8(%r12,%r13,8)
movq 0x8(%r15,%r13,8), %rdi
movq %rcx, %r13
testq %rdi, %rdi
jne 0x217a
jmp 0x21a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
movq $0x0, 0x8(%r12,%rcx,8)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fd4
nopl (%rax)