LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpq $0x0, 0xddba(%rip)      # 0x1b2f0
jne 0xd53a
jmp 0xd58f
movl 0x99e8(%rip), %eax      # 0x16f28
movl -0x4(%rbp), %ecx
imull 0xde6a(%rip), %ecx      # 0x1b3b4
addl %ecx, %eax
movw %ax, 0xdda5(%rip)       # 0x1b2f8
movl 0x99cf(%rip), %eax      # 0x16f28
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
imull 0xde4a(%rip), %ecx      # 0x1b3b0
addl %ecx, %eax
movw %ax, 0xdd8b(%rip)       # 0x1b2fa
movq 0xdd7a(%rip), %rdi      # 0x1b2f0
movq 0xdd83(%rip), %rdx      # 0x1b300
leaq 0x48c8(%rip), %rsi      # 0x11e4c
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x5250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xsetmode
void xsetmode(int set, unsigned int flags) {
  int mode = win.mode;
  MODBIT(win.mode, set, flags);

  // >>>>>>>>>>>>>>>>>>>> swap-mouse
  // ==================== swap-mouse
  // ==================== swap-mouse
  // <<<<<<<<<<<<<<<<<<<< swap-mouse

  if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
    redraw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0xdda4(%rip), %eax      # 0x1b3b8
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xd62e
movl -0x8(%rbp), %eax
orl 0xdd92(%rip), %eax      # 0x1b3b8
movl %eax, 0xdd8c(%rip)      # 0x1b3b8
jmp 0xd640
movl -0x8(%rbp), %eax
xorl $-0x1, %eax
andl 0xdd7e(%rip), %eax      # 0x1b3b8
movl %eax, 0xdd78(%rip)      # 0x1b3b8
movl 0xdd72(%rip), %eax      # 0x1b3b8
andl $0x20, %eax
movl -0xc(%rbp), %ecx
andl $0x20, %ecx
cmpl %ecx, %eax
je 0xd658
callq 0x8420
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xsetcursor
int xsetcursor(int cursor) {
  // >>>>>>>>>>>>>>>>>>>> blinking-cursor
  // ==================== blinking-cursor
  if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */
  // ==================== blinking-cursor
  // <<<<<<<<<<<<<<<<<<<< blinking-cursor
    return 1;
  win.cursor = cursor;

  // >>>>>>>>>>>>>>>>>>>> blinking-cursor
  // ==================== blinking-cursor
  // ==================== blinking-cursor
  // <<<<<<<<<<<<<<<<<<<< blinking-cursor

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xd674
cmpl $0x7, -0x8(%rbp)
jle 0xd67d
movl $0x1, -0x4(%rbp)
jmp 0xd68d
movl -0x8(%rbp), %eax
movl %eax, 0xdd36(%rip)      # 0x1b3bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xclear
void xclear(int x1, int y1, int x2, int y2) {
  // >>>>>>>>>>>>>>>>>>>> invert
  // ==================== invert
  XftDrawRect(xw.draw, &dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg],
      x1, y1, x2 - x1, y2 - y1);
  // ==================== invert
  // <<<<<<<<<<<<<<<<<<<< invert
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq 0xc58d(%rip), %rax      # 0x1b308
movq %rax, -0x20(%rbp)
movq 0xc422(%rip), %rax      # 0x1b1a8
movq %rax, -0x18(%rbp)
movl 0xc628(%rip), %eax      # 0x1b3b8
andl $0x20, %eax
cmpl $0x0, %eax
je 0xeda3
movl 0x796e(%rip), %eax      # 0x1670c
movl %eax, -0x24(%rbp)
jmp 0xedac
movl 0xc3f3(%rip), %eax      # 0x1b19c
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
subl -0x4(%rbp), %r8d
movl -0x10(%rbp), %r9d
subl -0x8(%rbp), %r9d
callq 0x53b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq 0x6c6d(%rip), %rax      # 0x15d80
movq %rax, -0x20(%rbp)
movq 0x6c6a(%rip), %rax      # 0x15d88
movq %rax, -0x18(%rbp)
movq 0x6c67(%rip), %rax      # 0x15d90
movq %rax, -0x30(%rbp)
movq 0x6c64(%rip), %rax      # 0x15d98
movq %rax, -0x28(%rbp)
movq 0xc161(%rip), %rdi      # 0x1b2a0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5690
movq %rax, 0xc193(%rip)      # 0x1b2e8
cmpq $0x0, 0xc18b(%rip)      # 0x1b2e8
jne 0xf16b
movl $0x0, -0x4(%rbp)
jmp 0xf24d
movq 0xc176(%rip), %rdi      # 0x1b2e8
leaq 0x2fd4(%rip), %rsi      # 0x1214d
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x55a0
cmpq $0x0, %rax
je 0xf1a6
movq 0x6e5b(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x2fbe(%rip), %rsi      # 0x1215d
movb $0x0, %al
callq 0x5840
xorl %edi, %edi
leaq 0x2fde(%rip), %rsi      # 0x1218d
leaq 0xc0ea(%rip), %rdx      # 0x1b2a0
addq $0x48, %rdx
addq $0x10, %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x56c0
movq %rax, 0xc130(%rip)      # 0x1b300
cmpq $0x0, 0xc118(%rip)      # 0x1b2f0
jne 0xf224
movq 0xc107(%rip), %rdi      # 0x1b2e8
movq 0xc0c8(%rip), %r8       # 0x1b2b0
leaq 0x2fab(%rip), %rsi      # 0x1219a
movl $0x408, %edx            # imm = 0x408
leaq 0x2faa(%rip), %rcx      # 0x121a5
leaq 0x2f4b(%rip), %r9       # 0x1214d
leaq -0x30(%rbp), %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x5030
movq %rax, 0xc0cc(%rip)      # 0x1b2f0
cmpq $0x0, 0xc0c4(%rip)      # 0x1b2f0
jne 0xf246
movq 0x6dbb(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x2f73(%rip), %rsi      # 0x121b2
movb $0x0, %al
callq 0x5840
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, 0xbb69(%rip) # 0x1b2e8
movq 0xbb1a(%rip), %rdi      # 0x1b2a0
xorl %eax, %eax
movl %eax, %r9d
leaq -0x532(%rip), %r8       # 0xf260
movq %r9, %rsi
movq %r9, %rdx
movq %r9, %rcx
callq 0x52f0
movq 0xbb59(%rip), %rdi      # 0x1b300
callq 0x5090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xgeommasktogravity
int xgeommasktogravity(int mask) {
  switch (mask & (XNegative | YNegative)) {
  case 0:
    return NorthWestGravity;
  case XNegative:
    return NorthEastGravity;
  case YNegative:
    return SouthWestGravity;
  }

  return SouthEastGravity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x30, %eax
movl %eax, -0xc(%rbp)
je 0xf818
jmp 0xf804
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0xf821
jmp 0xf80e
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0xf82a
jmp 0xf833
movl $0x1, -0x4(%rbp)
jmp 0xf83a
movl $0x3, -0x4(%rbp)
jmp 0xf83a
movl $0x7, -0x4(%rbp)
jmp 0xf83a
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xf85d
movl -0x4(%rbp), %eax
movl %eax, 0xbb4b(%rip)      # 0x1b3a8
cmpl $0x0, -0x8(%rbp)
je 0xf86c
movl -0x8(%rbp), %eax
movl %eax, 0xbb40(%rip)      # 0x1b3ac
movl 0xbb36(%rip), %eax      # 0x1b3a8
movl 0x76b0(%rip), %ecx      # 0x16f28
shll %ecx
subl %ecx, %eax
cltd
idivl 0xbb31(%rip)            # 0x1b3b4
movl %eax, -0xc(%rbp)
movl 0xbb20(%rip), %eax      # 0x1b3ac
movl 0x7696(%rip), %ecx      # 0x16f28
shll %ecx
subl %ecx, %eax
cltd
idivl 0xbb13(%rip)            # 0x1b3b0
movl %eax, -0x10(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0xf8b2
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xf8bc
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf8bc
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0x10(%rbp), %eax
jge 0xf8d4
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xf8de
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf8de
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x75e0
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xf920
movl 0xbaa0(%rip), %edi      # 0x1b3a0
movl 0xba9e(%rip), %esi      # 0x1b3a4
callq 0x73b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xresize
void xresize(int col, int row) {
  win.tw = col * win.cw;
  win.th = row * win.ch;

  XFreePixmap(xw.dpy, xw.buf);
  xw.buf = XCreatePixmap(
      xw.dpy,
      xw.win,
      win.w,
      win.h,
      // >>>>>>>>>>>>>>>>>>>> alpha
      // ==================== alpha
      DefaultDepth(xw.dpy, xw.scr)
      // ==================== alpha
      // <<<<<<<<<<<<<<<<<<<< alpha
    );
  XftDrawChange(xw.draw, xw.buf);
  xclear(0, 0, win.w, win.h);

  /* resize to new width */
  xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull 0xba7c(%rip), %eax      # 0x1b3b4
movl %eax, 0xba62(%rip)      # 0x1b3a0
movl -0x8(%rbp), %eax
imull 0xba68(%rip), %eax      # 0x1b3b0
movl %eax, 0xba56(%rip)      # 0x1b3a4
movq 0xb94b(%rip), %rdi      # 0x1b2a0
movq 0xb95c(%rip), %rsi      # 0x1b2b8
callq 0x57c0
movq 0xb938(%rip), %rdi      # 0x1b2a0
movq 0xb941(%rip), %rsi      # 0x1b2b0
movl 0xba33(%rip), %edx      # 0x1b3a8
movl 0xba31(%rip), %ecx      # 0x1b3ac
movq 0xb91e(%rip), %rax      # 0x1b2a0
movq 0xe8(%rax), %rax
movslq 0xb9f8(%rip), %r8       # 0x1b388
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x5830
movq %rax, 0xb911(%rip)      # 0x1b2b8
movq 0xb95a(%rip), %rdi      # 0x1b308
movq 0xb903(%rip), %rsi      # 0x1b2b8
callq 0x56a0
movl 0xb9e8(%rip), %edx      # 0x1b3a8
movl 0xb9e6(%rip), %ecx      # 0x1b3ac
xorl %esi, %esi
movl %esi, %edi
callq 0xed60
movq 0xb8ea(%rip), %rdi      # 0x1b2c0
movslq -0x4(%rbp), %rsi
shlq $0x4, %rsi
callq 0x5b20
movq %rax, 0xb8d6(%rip)      # 0x1b2c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xb686(%rip), %eax      # 0x1b3b8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0xfd59
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x8f77(%rip), %eax      # 0x18cc0
cmpl $0x0, %eax
jne 0xfd59
movq -0x8(%rbp), %rdi
callq 0x109c0
jmp 0xfd86
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10c30
cmpl $0x0, %eax
je 0xfd6e
jmp 0xfd86
movq -0x8(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0xfd86
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10eb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: bmotion
void bmotion(XEvent *e) {
  // >>>>>>>>>>>>>>>>>>>> hide-cursor
  // ==================== hide-cursor
  // ==================== hide-cursor
  // <<<<<<<<<<<<<<<<<<<< hide-cursor

  if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
    mousereport(e);
    return;
  }

  mousesel(e, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xb616(%rip), %eax      # 0x1b3b8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0xfdc9
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x8f07(%rip), %eax      # 0x18cc0
cmpl $0x0, %eax
jne 0xfdc9
movq -0x8(%rbp), %rdi
callq 0x109c0
jmp 0xfdd4
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10eb0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0xfe03
jmp 0xfea7
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0xfe5d
cmpq $0x0, 0xb4dc(%rip)      # 0x1b2f0
je 0xfe22
movq 0xb4d3(%rip), %rdi      # 0x1b2f0
callq 0x5620
movl 0xb590(%rip), %eax      # 0x1b3b8
orl $0x2, %eax
movl %eax, 0xb587(%rip)      # 0x1b3b8
xorl %edi, %edi
callq 0xd6f0
movl 0xb57a(%rip), %eax      # 0x1b3b8
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xfe5b
leaq 0x274e(%rip), %rdi      # 0x1259d
movl $0x3, %esi
xorl %edx, %edx
callq 0x6f80
jmp 0xfea7
cmpq $0x0, 0xb48b(%rip)      # 0x1b2f0
je 0xfe73
movq 0xb482(%rip), %rdi      # 0x1b2f0
callq 0x53a0
movl 0xb53f(%rip), %eax      # 0x1b3b8
andl $-0x3, %eax
movl %eax, 0xb536(%rip)      # 0x1b3b8
movl 0xb530(%rip), %eax      # 0x1b3b8
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xfea5
leaq 0x2708(%rip), %rdi      # 0x125a1
movl $0x3, %esi
xorl %edx, %edx
callq 0x6f80
jmp 0xfea7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: zoomreset
void zoomreset(const Arg *arg) {
  Arg larg;

  if (defaultfontsize > 0) {
    larg.f = defaultfontsize;
    zoomabs(&larg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd 0xacd4(%rip), %xmm0     # 0x1b478
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x107c7
movsd 0xacc3(%rip), %xmm0     # 0x1b478
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x10890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x108e0
movq 0xabb8(%rip), %rdi      # 0x1b460
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0xedf0
xorl %esi, %esi
movl %esi, %edi
callq 0xf840
callq 0x8420
callq 0xf2b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: xunloadfonts
void xunloadfonts(void) {
  // >>>>>>>>>>>>>>>>>>>> ligatures
  // ==================== ligatures
  // ==================== ligatures
  // <<<<<<<<<<<<<<<<<<<< ligatures

  /* Free the loaded fonts in the font cache.  */
  while (frclen > 0)
    XftFontClose(xw.dpy, frc[--frclen].font);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x108e6
cmpl $0x0, 0xab5b(%rip)      # 0x1b448
jle 0x10920
movq 0xa9aa(%rip), %rdi      # 0x1b2a0
movq 0xab53(%rip), %rax      # 0x1b450
movl 0xab45(%rip), %ecx      # 0x1b448
addl $-0x1, %ecx
movl %ecx, 0xab3c(%rip)      # 0x1b448
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x50d0
jmp 0x108e6
leaq 0xa881(%rip), %rdi      # 0x1b1a8
addq $0x10, %rdi
callq 0x10970
leaq 0xa871(%rip), %rdi      # 0x1b1a8
addq $0x48, %rdi
callq 0x10970
leaq 0xa861(%rip), %rdi      # 0x1b1a8
addq $0x80, %rdi
callq 0x10970
leaq 0xa84e(%rip), %rdi      # 0x1b1a8
addq $0xb8, %rdi
callq 0x10970
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: evcol
int evcol(XEvent *e) {
  // >>>>>>>>>>>>>>>>>>>> anysize
  // ==================== anysize
  int x = e->xbutton.x - borderpx;
  // ==================== anysize
  // <<<<<<<<<<<<<<<<<<<< anysize
  LIMIT(x, 0, win.tw - 1);
  return x / win.cw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
subl 0x6203(%rip), %eax      # 0x16f28
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x10d35
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x10d5f
movl -0xc(%rbp), %eax
movl 0xa662(%rip), %ecx      # 0x1b3a0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x10d53
movl 0xa655(%rip), %eax      # 0x1b3a0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10d59
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl 0xa645(%rip)            # 0x1b3b4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: evrow
int evrow(XEvent *e) {
  // >>>>>>>>>>>>>>>>>>>> anysize
  // ==================== anysize
  int y = e->xbutton.y - borderpx;
  // ==================== anysize
  // <<<<<<<<<<<<<<<<<<<< anysize
  LIMIT(y, 0, win.th - 1);
  return y / win.ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
subl 0x6193(%rip), %eax      # 0x16f28
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x10da5
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x10dcf
movl -0xc(%rbp), %eax
movl 0xa5f6(%rip), %ecx      # 0x1b3a4
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x10dc3
movl 0xa5e9(%rip), %eax      # 0x1b3a4
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10dc9
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl 0xa5d1(%rip)            # 0x1b3b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaimecgomezz[P]st/x.c
// Function: buttonmask
uint buttonmask(uint button) {
  return button == Button1
             ? Button1Mask
             : button == Button2
                   ? Button2Mask
                   : button == Button3
                         ? Button3Mask
                         : button == Button4
                               ? Button4Mask
                               : button == Button5 ? Button5Mask : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x10e07
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
jmp 0x10e5c
cmpl $0x2, -0x4(%rbp)
jne 0x10e17
movl $0x200, %eax            # imm = 0x200
movl %eax, -0xc(%rbp)
jmp 0x10e56
cmpl $0x3, -0x4(%rbp)
jne 0x10e27
movl $0x400, %eax            # imm = 0x400
movl %eax, -0x10(%rbp)
jmp 0x10e50
cmpl $0x4, -0x4(%rbp)
jne 0x10e37
movl $0x800, %eax            # imm = 0x800
movl %eax, -0x14(%rbp)
jmp 0x10e4a
movl -0x4(%rbp), %edx
xorl %eax, %eax
movl $0x1000, %ecx           # imm = 0x1000
cmpl $0x5, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1040
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, 0x9e0f(%rip)      # 0xb0d0
je 0x12f2
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x9dfa(%rip), %rdi      # 0xb0cc
leaq 0x9df7(%rip), %rsi      # 0xb0d0
callq 0x1350
cmpl $0x0, %eax
jne 0x12f0
movl -0x1c(%rbp), %edi
callq 0x1270
movl %eax, -0x4(%rbp)
jmp 0x1342
jmp 0x1321
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x9dcb(%rip), %rdi      # 0xb0cc
leaq 0x9dc8(%rip), %rsi      # 0xb0d0
callq 0x1450
cmpl $0x0, %eax
jne 0x131f
movl -0x1c(%rbp), %edi
callq 0x1270
movl %eax, -0x4(%rbp)
jmp 0x1342
jmp 0x1321
callq 0x1040
cmpl $0x1, (%rax)
je 0x133b
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x1040
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_line.c
// Function: previous_is_eof
static int			previous_is_eof(int *ret, int *eof, char **line,\
t_minishell_meta *ms)
{
	char		*bef_line;
	char		*new_line;

	bef_line = *line;
	new_line = 0;
	*ret = get_next_line(0, &new_line);
	check_ret_lt_zero(ret, new_line, line, ms);
	check_ret_eq_zero(ret, new_line, bef_line, ms);
	if (errno != 1)
		errno_ne_one(line, bef_line, new_line);
	else
		errno_eq_one(line, new_line);
	if (*ret == 1 && errno == 2)
	{
		ft_putstr("  \b\b");
		return (0);
	}
	if (*ret > 0)
		*eof = 0;
	if (*ret == 0)
	{
		ft_putstr("  \b\b");
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
xorl %edi, %edi
leaq -0x38(%rbp), %rsi
callq 0x1740
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1540
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x15a0
callq 0x1040
cmpl $0x1, (%rax)
je 0x13d5
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x16b0
jmp 0x13e2
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1700
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x140a
callq 0x1040
cmpl $0x2, (%rax)
jne 0x140a
leaq 0x6c08(%rip), %rdi      # 0x8004
callq 0x6ee0
movl $0x0, -0x4(%rbp)
jmp 0x1442
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x141d
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x143b
leaq 0x6bd7(%rip), %rdi      # 0x8004
callq 0x6ee0
movl $0x0, -0x4(%rbp)
jmp 0x1442
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_line.c
// Function: current_line_handle
static int			current_line_handle(int *ret, int *eof, char **line,\
t_minishell_meta *ms)
{
	*ret = get_next_line(0, &(*line));
	if (*ret == -1)
	{
		ft_free(line);
		free_tab(ms->env);
		free(ms);
		exit(0);
	}
	if (*ret == 1 && errno == 2)
	{
		*eof = 1;
		ft_putstr("  \b\b");
		return (0);
	}
	if ((*ret == 0 && ft_strlen(*line)))
	{
		*eof = 1;
		ft_putstr("  \b\b");
		return (0);
	}
	check_ret_and_line(ret, line, ms);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x1740
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x14aa
movq -0x20(%rbp), %rdi
callq 0x1b80
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3670
movq -0x28(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1140
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x14dc
callq 0x1040
cmpl $0x2, (%rax)
jne 0x14dc
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
leaq 0x6b36(%rip), %rdi      # 0x8004
callq 0x6ee0
movl $0x0, -0x4(%rbp)
jmp 0x152d
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1515
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1bd0
cmpl $0x0, %eax
je 0x1515
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
leaq 0x6afd(%rip), %rdi      # 0x8004
callq 0x6ee0
movl $0x0, -0x4(%rbp)
jmp 0x152d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1630
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x1594
movq -0x18(%rbp), %rdi
callq 0x1b80
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3670
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3670
movq -0x20(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1626
callq 0x1040
cmpl $0x1, (%rax)
jne 0x1626
movq -0x10(%rbp), %rdi
callq 0x1bd0
cmpl $0x0, %eax
jne 0x1626
leaq -0x18(%rbp), %rdi
callq 0x1b80
leaq -0x10(%rbp), %rdi
callq 0x1b80
leaq 0x6a17(%rip), %rdi      # 0x8009
movl $0x1, %esi
callq 0x6e70
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3670
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3670
movq -0x20(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x16a2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1bd0
cmpl $0x0, %eax
jne 0x16a2
movq -0x10(%rbp), %rdi
callq 0x1b80
leaq 0x699b(%rip), %rdi      # 0x8009
movl $0x1, %esi
callq 0x6e70
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3670
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3670
movq -0x18(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line.c
// Function: get_next_line
int					get_next_line(int fd, char **line)
{
	static char		*p;
	char			*buffer;
	int				value;
	int				ret;

	value = 1;
	errno = 0;
	if (validate(fd, line))
		return (-1);
	while (value > 0)
	{
		if (!(buffer = init(buffer, &p, fd)))
			return (-1);
		if ((!(value = ft_strlen(buffer))))
		{
			ft_free(&p);
			ft_free(&buffer);
			if (!(*line))
				*line = ft_strdup("");
			return (0);
		}
		if ((ret = ft_some(&p, value, buffer, line)) == 1 || ret == -1)
			return (ret);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
callq 0x1040
movl $0x0, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1850
cmpl $0x0, %eax
je 0x177e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x183b
jmp 0x1780
cmpl $0x0, -0x1c(%rbp)
jle 0x1834
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0x9940(%rip), %rsi      # 0xb0d8
callq 0x18a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x183b
movq -0x18(%rbp), %rdi
callq 0x1bd0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x1802
leaq 0x990d(%rip), %rdi      # 0xb0d8
callq 0x1b80
leaq -0x18(%rbp), %rdi
callq 0x1b80
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17f9
leaq 0x681e(%rip), %rdi      # 0x8008
callq 0x1c00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x183b
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x98c4(%rip), %rdi      # 0xb0d8
callq 0x1960
movl %eax, -0x20(%rbp)
cmpl $0x1, %eax
je 0x1827
cmpl $-0x1, -0x20(%rbp)
jne 0x182f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x183b
jmp 0x1780
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line.c
// Function: validate
static int			validate(int fd, char **line)
{
	if (fd < 0)
		return (1);
	if (line == NULL)
		return (1);
	*line = 0;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x186a
movl $0x1, -0x4(%rbp)
jmp 0x188c
cmpq $0x0, -0x10(%rbp)
jne 0x187a
movl $0x1, -0x4(%rbp)
jmp 0x188c
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line.c
// Function: init
static char			*init(char *buffer, char **p, int fd)
{
	int		value;
	char	*tmp;

	value = 0;
	if (!(buffer = malloc(sizeof(char) * (BUFFER_SIZE + 1))))
		return (NULL);
	if ((value = read(fd, buffer, BUFFER_SIZE)) < 0)
		return (NULL);
	buffer[value] = '\0';
	if (*p != NULL)
	{
		tmp = ft_strjoin(*p, buffer);
		ft_free(&buffer);
		ft_free(p);
		buffer = tmp;
	}
	return (buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0xb, %edi
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x18d8
movq $0x0, -0x8(%rbp)
jmp 0x1947
movl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x10c0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x18fb
movq $0x0, -0x8(%rbp)
jmp 0x1947
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x193f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b80
movq -0x18(%rbp), %rdi
callq 0x1b80
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line.c
// Function: ft_some
static int			ft_some(char **p, int value, char *buffer, char **line)
{
	int			i;

	i = 0;
	while (i < value)
	{
		if ((buffer[i] == '\n') || (buffer[i + 1] == '\0'))
		{
			if (!(*p = process_new_line(*p, value, i, buffer)))
				return (-1);
			if (*line == NULL && (*line = malloc(sizeof(char))))
				*line[0] = '\0';
			if ((buffer[i]) != '\n' && (buffer[i + 1] == '\0'))
			{
				errno = 2;
				*line = ft_stradd(*line, buffer[i]);
			}
			ft_free(&buffer);
			return (1);
		}
		else if (ft_free(p))
			*line = ft_stradd(*line, buffer[i++]);
	}
	ft_free(&buffer);
	return (2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1ab6
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x19b5
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1a75
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x1ad0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x19e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1ac6
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1a0f
movl $0x1, %edi
callq 0x1110
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x1a0f
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x1a63
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1a63
callq 0x1040
movl $0x2, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x1dc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x1b80
movl $0x1, -0x4(%rbp)
jmp 0x1ac6
movq -0x10(%rbp), %rdi
callq 0x1b80
cmpl $0x0, %eax
je 0x1aaf
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %esi
callq 0x1dc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1ab1
jmp 0x197e
leaq -0x20(%rbp), %rdi
callq 0x1b80
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line.c
// Function: process_new_line
static char			*process_new_line(char *p, int value, int i, char *buffer)
{
	int j;

	j = 0;
	p = malloc(sizeof(char) * (value - i));
	if (p == NULL)
		return (0);
	i++;
	while (buffer[i] != '\0')
		p[j++] = buffer[i++];
	p[j] = '\0';
	return (p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b14
movq $0x0, -0x8(%rbp)
jmp 0x1b6e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1b5a
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1b1d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line_utils.c
// Function: ft_free
int				ft_free(char **str)
{
	if (!str || !*str)
		return (1);
	free(*str);
	*str = 0;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b9d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1ba6
movl $0x1, -0x4(%rbp)
jmp 0x1bc4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/get_next_line_utils.c
// Function: ft_strlen
int				ft_strlen(const char *s)
{
	int i;

	i = 0;
	while (s[i] != '\0')
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1bfb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bdf
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bd0
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1c46
movq $0x0, -0x8(%rbp)
jmp 0x1c94
jmp 0x1c48
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1c80
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c48
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
jne 0x1cd2
movq $0x0, -0x8(%rbp)
jmp 0x1db2
cmpq $0x0, -0x18(%rbp)
jne 0x1ceb
movq -0x10(%rbp), %rdi
callq 0x1c00
movq %rax, -0x8(%rbp)
jmp 0x1db2
movq -0x10(%rbp), %rdi
callq 0x1bd0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bd0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x1110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d2f
movq $0x0, -0x8(%rbp)
jmp 0x1db2
jmp 0x1d31
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1d62
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1d31
jmp 0x1d64
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1d9e
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d64
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1def
movq -0x10(%rbp), %rdi
callq 0x1bd0
movl %eax, -0x2c(%rbp)
jmp 0x1df6
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1df6
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e2a
movq $0x0, -0x8(%rbp)
jmp 0x1eb0
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
je 0x1e5a
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x1e63
jmp 0x1e7b
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1e31
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
leaq -0x10(%rbp), %rdi
callq 0x1b80
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1f14
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2, %esi
callq 0x6f10
leaq 0x6110(%rip), %rdi      # 0x800f
movl $0x2, %esi
callq 0x6f10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ed3
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x3c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x6840
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6037(%rip), %rsi      # 0x8012
callq 0x74f0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b80
movq -0x18(%rbp), %rdi
callq 0x1c00
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1b80
movq -0x8(%rbp), %rdi
callq 0x1f20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3d20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x204f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x204f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5610
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37a0
jmp 0x205c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37a0
movl $0x1, %edi
leaq 0x5fb1(%rip), %rsi      # 0x8019
movl $0xf, %edx
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bd0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x20d1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6bd0
cmpl $0x0, %eax
jne 0x20c6
movl $0x0, -0x4(%rbp)
jmp 0x20d8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x209f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)