LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: wintomon
Monitor *
wintomon(Window w) {
   int x, y;
   Client *c;
   Monitor *m;

   if(w == root && getrootptr(&x, &y))
      return ptrtomon(x, y);
   for(m = mons; m; m = m->next)
      if(w == m->barwin)
         return m;
   if((c = wintoclient(w)))
      return c->mon;
   return selmon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x11509(%rip), %rax     # 0x187e0
jne 0x72fc
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8860
cmpl $0x0, %eax
je 0x72fc
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x88b0
movq %rax, -0x8(%rbp)
jmp 0x736b
movq 0x112f5(%rip), %rax     # 0x185f8
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x733c
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x7329
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x736b
jmp 0x732b
movq -0x28(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7307
movq -0x10(%rbp), %rdi
callq 0x8940
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7360
movq -0x20(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x736b
movq 0x11299(%rip), %rax     # 0x18600
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/Cloudef[P]dwm-fork/dwm.c
// Function: monocle
void
monocle(Monitor *m) {
   unsigned int n = 0;
   Client *c;

   for(c = m->clients; c; c = c->next)
      if(ISVISIBLE(c) && !c->iswidget)
         n++;
   if(n > 0) /* override layout symbol */
      snprintf(m->ltsymbol, sizeof m->ltsymbol, "[%d]", n);
   for(c = nexttiled(m->clients); c; c = nexttiled(c->next))
      resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f18
movq -0x18(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0x7eef
movq -0x18(%rbp), %rax
movl 0x15c(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0x7f05
movq -0x18(%rbp), %rax
cmpl $0x0, 0x170(%rax)
jne 0x7f05
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7f07
movq -0x18(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7eaf
cmpl $0x0, -0xc(%rbp)
jbe 0x7f38
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x10, %esi
leaq 0xa5ed(%rip), %rdx      # 0x1251e
movb $0x0, %al
callq 0x50b0
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x7fc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7fac
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x150(%rax), %eax
shll %eax
subl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x44(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x150(%rax), %eax
shll %eax
subl %eax, %r8d
xorl %r9d, %r9d
callq 0x8060
movq -0x18(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0x7fc0
movq %rax, -0x18(%rbp)
jmp 0x7f49
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: resizeclient
void
resizeclient(Client *c, int x, int y, int w, int h) {
   XWindowChanges wc;

   /* store old floating positions */
   if(c->isfloating && !c->isfullscreen)
   {
      c->fw = c->w;
      c->fh = c->h;
   }
   c->oldx = c->x; c->x = wc.x = x;
   c->oldy = c->y; c->y = wc.y = y;
   c->oldw = c->w; c->w = wc.width = w;
   c->oldh = c->h; c->h = wc.height = h;
   wc.border_width = c->bw;
   XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc);
   configure(c);
   XSync(dpy, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x168(%rax)
je 0x86bb
movq -0x8(%rbp), %rax
cmpl $0x0, 0x160(%rax)
jne 0x86bb
movq -0x8(%rbp), %rax
movl 0x110(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x128(%rax)
movq -0x8(%rbp), %rax
movl 0x114(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x12c(%rax)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x118(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x11c(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x10c(%rax)
movq -0x8(%rbp), %rax
movl 0x110(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x120(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x110(%rax)
movq -0x8(%rbp), %rax
movl 0x114(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x124(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl %ecx, 0x114(%rax)
movq -0x8(%rbp), %rax
movl 0x150(%rax), %eax
movl %eax, -0x30(%rbp)
movq 0xfeb9(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movl $0x1f, %edx
leaq -0x40(%rbp), %rcx
callq 0x50e0
movq -0x8(%rbp), %rdi
callq 0x87a0
movq 0xfe90(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: configure
void
configure(Client *c) {
   XConfigureEvent ce;

   ce.type = ConfigureNotify;
   ce.display = dpy;
   ce.event = c->win;
   ce.window = c->win;
   ce.x = c->x;
   ce.y = c->y;
   ce.width = c->w;
   ce.height = c->h;
   ce.border_width = c->bw;
   ce.above = None;
   ce.override_redirect = False;
   XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x16, -0x60(%rbp)
movq 0xfe5e(%rip), %rax      # 0x18618
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x110(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x114(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x150(%rax), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq 0xfde5(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x60(%rbp), %r8
callq 0x5500
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: ptrtomon
Monitor *
ptrtomon(int x, int y) {
   Monitor *m;

   for(m = mons; m; m = m->next)
      if(INRECT(x, y, m->wx, m->wy, m->ww, m->wh))
         return m;
   return selmon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq 0xfd37(%rip), %rax      # 0x185f8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x892b
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jl 0x8918
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x38(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x40(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8918
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jl 0x8918
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x3c(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x44(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8918
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8936
jmp 0x891a
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x88c5
movq 0xfcce(%rip), %rax      # 0x18600
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: wintoclient
Client *
wintoclient(Window w) {
   Client *c;
   Monitor *m;

   for(m = mons; m; m = m->next)
      for(c = m->clients; c; c = c->next)
         if(c->win == w)
            return c;
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0xfca9(%rip), %rax      # 0x185f8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x89ae
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x899b
movq -0x18(%rbp), %rax
movq 0x1a8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x8988
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x89b6
jmp 0x898a
movq -0x18(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8966
jmp 0x899d
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8953
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: gettextprop
Bool
gettextprop(Window w, Atom atom, char *text, unsigned int size) {
   char **list = NULL;
   int n;
   XTextProperty name;

   if(!text || size == 0)
      return False;
   text[0] = '\0';
   XGetTextProperty(dpy, w, &name, atom);
   if(!name.nitems)
      return False;
   if(name.encoding == XA_STRING)
      strncpy(text, (char *)name.value, size - 1);
   else {
      if(XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success && n > 0 && *list) {
         strncpy(text, *list, size - 1);
         XFreeStringList(list);
      }
   }
   text[size - 1] = '\0';
   XFree(name.value);
   return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x89ec
cmpl $0x0, -0x24(%rbp)
jne 0x89f8
movl $0x0, -0x4(%rbp)
jmp 0x8abc
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq 0xfc12(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x58(%rbp), %rdx
callq 0x5300
cmpq $0x0, -0x40(%rbp)
jne 0x8a2a
movl $0x0, -0x4(%rbp)
jmp 0x8abc
cmpq $0x1f, -0x50(%rbp)
jne 0x8a4a
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x5620
jmp 0x8a9c
movq 0xfbc7(%rip), %rdi      # 0x18618
leaq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x5250
cmpl $0x0, %eax
jl 0x8a9a
cmpl $0x0, -0x34(%rbp)
jle 0x8a9a
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8a9a
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x5620
movq -0x30(%rbp), %rdi
callq 0x5590
jmp 0x8a9c
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x58(%rbp), %rdi
callq 0x5070
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: textnw
int
textnw(const char *text, unsigned int len) {

   // remove non-printing color codes before calculating width
   char *ptr = (char *) text;
   unsigned int i, ibuf, lenbuf=len;
   char buf[len + 1];

   for(i=0, ibuf=0; *ptr && i<len; i++, ptr++) {
      if(*ptr <= MAXCOLORS && *ptr > 0) {
         if (i < len) { lenbuf--; }
      } else {
         buf[ibuf]=*ptr;
         ibuf++;
      }
   }
   buf[ibuf]=0;

#ifdef XFT
   PangoRectangle r;
   pango_layout_set_text(dc.plo, buf, lenbuf);
   pango_layout_get_extents(dc.plo, &r, 0);
   return r.width / PANGO_SCALE;
#else
   if(dc.font.set) {
      XRectangle r;
      XmbTextExtents(dc.font.set, buf, lenbuf, NULL, &r);
      return r.width;
   } else {
      return XTextWidth(dc.font.xfont, buf, lenbuf);
   }
#endif

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x59(%rbp)
je 0x9700
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x9709
jmp 0x9769
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xc, %eax
jg 0x9734
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jle 0x9734
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x9732
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x974d
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rcx), %dl
movl -0x28(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x974f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x96e3
movq -0x58(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x0, (%rax,%rcx)
cmpq $0x0, 0xf054(%rip)      # 0x187d0
je 0x97a9
movq -0x58(%rbp), %rsi
movq 0xf047(%rip), %rdi      # 0x187d0
movl -0x2c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x48(%rbp), %r8
callq 0x5600
movzwl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x97c6
movq -0x58(%rbp), %rsi
movq 0xf024(%rip), %rdi      # 0x187d8
movl -0x2c(%rbp), %edx
callq 0x54c0
movl %eax, -0x4(%rbp)
movl $0x1, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: drawsquare
void
drawsquare(Bool filled, Bool empty, Bool invert, size_t col_index) {
   int x;
   XGCValues gcv;
   XRectangle r = { dc.x, dc.y, dc.w, dc.h };

   gcv.foreground = dc.colors[col_index][invert ? ColBG : ColFG];
   XChangeGC(dpy, dc.gc, GCForeground, &gcv);
   x = (dc.font.ascent + dc.font.descent + 2) / 4;
   r.x = dc.x + 1;
   r.y = dc.y + 1;
   if(filled) {
      r.width = r.height = x + 1;
      XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
   }
   else if(empty) {
      r.width = r.height = x;
      XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl 0xeac2(%rip), %eax      # 0x18680
movw %ax, -0xa8(%rbp)
movl 0xeab9(%rip), %eax      # 0x18684
movw %ax, -0xa6(%rbp)
movl 0xeab0(%rip), %eax      # 0x18688
movw %ax, -0xa4(%rbp)
movl 0xeaa7(%rip), %eax      # 0x1868c
movw %ax, -0xa2(%rbp)
leaq 0xea8d(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl -0xc(%rbp), %esi
movl $0x1, %ecx
movl $0x2, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x90(%rbp)
movq 0xe9f1(%rip), %rdi      # 0x18618
movq 0xeb8a(%rip), %rsi      # 0x187b8
movl $0x4, %edx
leaq -0xa0(%rbp), %rcx
callq 0x5510
movl 0xeb7b(%rip), %eax      # 0x187c0
addl 0xeb79(%rip), %eax      # 0x187c4
addl $0x2, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl 0xea21(%rip), %eax      # 0x18680
addl $0x1, %eax
movw %ax, -0xa8(%rbp)
movl 0xea15(%rip), %eax      # 0x18684
addl $0x1, %eax
movw %ax, -0xa6(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x9cbc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movw %ax, -0xa2(%rbp)
movw %ax, -0xa4(%rbp)
movq 0xe97e(%rip), %rdi      # 0x18618
movq 0xeb0f(%rip), %rsi      # 0x187b0
movq 0xeb10(%rip), %rdx      # 0x187b8
leaq -0xa8(%rbp), %rcx
movl $0x1, %r8d
callq 0x5320
jmp 0x9cfc
cmpl $0x0, -0x8(%rbp)
je 0x9cfa
movl -0x1c(%rbp), %eax
movw %ax, -0xa2(%rbp)
movw %ax, -0xa4(%rbp)
movq 0xe93e(%rip), %rdi      # 0x18618
movq 0xeacf(%rip), %rsi      # 0x187b0
movq 0xead0(%rip), %rdx      # 0x187b8
leaq -0xa8(%rbp), %rcx
movl $0x1, %r8d
callq 0x5280
jmp 0x9cfc
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: drawicon
void
drawicon(const char *file, size_t col_index, unsigned int *width, unsigned int *height) {
   Pixmap icon;
   unsigned int x, pw, ph;
   int ix, iy;

   x = dc.x;
   icon = XCreatePixmap(dpy, dc.drawable, 12, 12, 1);
   XReadBitmapFile(dpy, dc.drawable, file, &pw, &ph, &icon, &ix, &iy); pw += 3;
   XSetForeground(dpy, dc.gc, dc.colors[col_index][ColBG]);
   XFillRectangle(dpy, dc.drawable, dc.gc, x, 0, pw, bh);
   XSetForeground(dpy, dc.gc, dc.colors[col_index][ColFG]);
   XSetBackground(dpy, dc.gc, dc.colors[col_index][ColBG]);
   XCopyPlane(dpy, icon, dc.drawable, dc.gc, ix, iy - 1, pw, bh, x, 1, 1);

   *width  = pw;
   *height = ph;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0xe952(%rip), %eax      # 0x18680
movl %eax, -0x2c(%rbp)
movq 0xe8e0(%rip), %rdi      # 0x18618
movq 0xea71(%rip), %rsi      # 0x187b0
movl $0xc, %ecx
movl $0x1, %r8d
movl %ecx, %edx
callq 0x5710
movq %rax, -0x28(%rbp)
movq 0xe8bc(%rip), %rdi      # 0x18618
movq 0xea4d(%rip), %rsi      # 0x187b0
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x38(%rbp), %r10
leaq -0x3c(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x51b0
movl -0x30(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x30(%rbp)
movq 0xe87f(%rip), %rdi      # 0x18618
movq 0xea18(%rip), %rsi      # 0x187b8
leaq 0xe8d9(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
callq 0x5340
movq 0xe855(%rip), %rdi      # 0x18618
movq 0xe9e6(%rip), %rsi      # 0x187b0
movq 0xe9e7(%rip), %rdx      # 0x187b8
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movl 0xea26(%rip), %eax      # 0x18804
xorl %r8d, %r8d
movl %eax, (%rsp)
callq 0x5350
movq 0xe828(%rip), %rdi      # 0x18618
movq 0xe9c1(%rip), %rsi      # 0x187b8
leaq 0xe882(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x5340
movq 0xe7fe(%rip), %rdi      # 0x18618
movq 0xe997(%rip), %rsi      # 0x187b8
leaq 0xe858(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
callq 0x53c0
movq 0xe7d4(%rip), %rdi      # 0x18618
movq -0x28(%rbp), %rsi
movq 0xe961(%rip), %rdx      # 0x187b0
movq 0xe962(%rip), %rcx      # 0x187b8
movl -0x38(%rbp), %r8d
movl -0x3c(%rbp), %r9d
subl $0x1, %r9d
movl -0x30(%rbp), %r11d
movl 0xe997(%rip), %r10d     # 0x18804
movl -0x2c(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
callq 0x55d0
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: systray_get_width
int
systray_get_width(void) {
   int w = 0;
   Systray *i;

   if(!systray_enable) return 0;

   for(i = trayicons; i; i = i->next)
      w += i->geo.width + systray_spacing;

   return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movq 0xe75e(%rip), %rax      # 0x18620
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9eec
movq -0x10(%rbp), %rax
movzwl 0xc(%rax), %eax
addl $0x2, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9ec6
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: drawcoloredtext
void
drawcoloredtext(char *text) {
   char *buf = text, *ptr = buf, c = 1;
   size_t col = 0;
   int i, ox = dc.x;

   while( *ptr ) {
      for( i = 0; *ptr < 0 || *ptr > MAXCOLORS; i++, ptr++);
      if( !*ptr ) break;
      c=*ptr;
      *ptr=0;
      if( i ) {
         dc.w = selmon->ww - dc.x;
         drawtext(buf, col, False);
         dc.x += textnw(buf, i);
      }
      *ptr = c;
      col = c-1;
      buf = ++ptr;
   }
   drawtext(buf, col, False);
   dc.x = ox;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movl 0xe752(%rip), %eax      # 0x18680
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa011
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jl 0x9f66
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xc, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9f6f
jmp 0x9f88
jmp 0x9f71
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9f45
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x9f93
jmp 0xa011
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x2c(%rbp)
je 0x9fe6
movq 0xe650(%rip), %rax      # 0x18600
movl 0x40(%rax), %eax
subl 0xe6c7(%rip), %eax      # 0x18680
movl %eax, 0xe6c9(%rip)      # 0x18688
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x97e0
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x9690
addl 0xe6a0(%rip), %eax      # 0x18680
movl %eax, 0xe69a(%rip)      # 0x18680
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movsbl -0x19(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
jmp 0x9f31
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x97e0
movl -0x30(%rbp), %eax
movl %eax, 0xe657(%rip)      # 0x18680
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: systray_freeicons
void
systray_freeicons(void) {
   Systray *i, *next;

   if(!systray_enable) return;

   for(i = trayicons; i; i = next) {
      XUnmapWindow(dpy, i->win);
      XReparentWindow(dpy, i->win, ROOT, 0, 0);
      next = i->next; IFREE(i);
   }

   XSetSelectionOwner(dpy, netatom[NetSystemTray], None, CurrentTime);
   XDestroyWindow(dpy, traywin);
   XSync(dpy, False);

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xe4c1(%rip), %rax      # 0x18620
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa1e8
movq 0xe4a7(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5360
movq 0xe494(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0xe486(%rip), %rax      # 0x18618
movq 0xe8(%rax), %rax
movq 0xe478(%rip), %rcx      # 0x18618
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x56f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa1d9
movq -0x8(%rbp), %rdi
callq 0x52b0
jmp 0xa1db
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa163
movq 0xe429(%rip), %rdi      # 0x18618
movq 0xe47a(%rip), %rsi      # 0x18670
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x54e0
movq 0xe40f(%rip), %rdi      # 0x18618
movq 0xe418(%rip), %rsi      # 0x18628
callq 0x5310
movq 0xe3fc(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: dwm_send_message
void
dwm_send_message(Window d, Window w, char *atom, long d0, long d1, long d2, long d3, long d4)
{

   XClientMessageEvent e;

   e.type          = ClientMessage;
   e.message_type  = ATOM(atom);
   e.window        = w;
   e.format        = 32;
   e.data.l[0]     = d0;
   e.data.l[1]     = d1;
   e.data.l[2]     = d2;
   e.data.l[3]     = d3;
   e.data.l[4]     = d4;

   XSendEvent(dpy, d, False, StructureNotifyMask, (XEvent*)&e);
   XSync(dpy, False);

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x21, -0x90(%rbp)
movq 0xe3ac(%rip), %rdi      # 0x18618
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x55f0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x20, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xe35f(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x90(%rbp), %r8
callq 0x5500
movq 0xe341(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: updatenumlockmask
void
updatenumlockmask(void) {
   unsigned int i, j;
   XModifierKeymap *modmap;

   numlockmask = 0;
   modmap = XGetModifierMapping(dpy);
   for(i = 0; i < 8; i++)
      for(j = 0; j < modmap->max_keypermod; j++)
         if(modmap->modifiermap[i * modmap->max_keypermod + j]
               == XKeysymToKeycode(dpy, XK_Num_Lock))
            numlockmask = (1 << i);
   XFreeModifiermap(modmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, 0xe666(%rip)      # 0x18968
movq 0xe30f(%rip), %rdi      # 0x18618
callq 0x55e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jae 0xa396
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa389
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull (%rdx), %ecx
addl -0x8(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq 0xe2c2(%rip), %rdi      # 0x18618
movl $0xff7f, %esi           # imm = 0xFF7F
callq 0x5640
movb %al, %cl
movl -0x14(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0xa37c
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xe5ec(%rip)      # 0x18968
jmp 0xa37e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa326
jmp 0xa38b
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa319
movq -0x10(%rbp), %rdi
callq 0x51d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: togglebar
void
togglebar(const Arg *arg) {
   Client *c;

   if(!selmon) return;

   for(c = selmon->clients; c; c = c->next)
   {
      if(ISVISIBLE(c) && c->isfullscreen)
         return; /* there is a fullscreen window on this monitor, don't toggle */
   }

   if(arg && arg->i != -1)
   {
      selmon->showbartoggle = arg->i;
      togglebarm(selmon, arg->i);
   }
   else
   {
      selmon->showbartoggle = selmon->showbar;
      togglebarm(selmon, !selmon->showbar);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xdebc(%rip)      # 0x18600
jne 0xa74b
jmp 0xa825
movq 0xdeae(%rip), %rax      # 0x18600
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa7bc
movq -0x10(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xa79a
movq -0x10(%rbp), %rax
movl 0x15c(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0xa7a9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x160(%rax)
je 0xa7a9
jmp 0xa825
jmp 0xa7ab
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa75a
cmpq $0x0, -0x8(%rbp)
je 0xa7f0
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xa7f0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq 0xde27(%rip), %rax      # 0x18600
movl %ecx, 0x6c(%rax)
movq 0xde1d(%rip), %rdi      # 0x18600
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0xbe10
jmp 0xa825
movq 0xde09(%rip), %rax      # 0x18600
movl 0x68(%rax), %ecx
movq 0xddff(%rip), %rax      # 0x18600
movl %ecx, 0x6c(%rax)
movq 0xddf5(%rip), %rdi      # 0x18600
movq 0xddee(%rip), %rax      # 0x18600
cmpl $0x0, 0x68(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0xbe10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: setmfact
void
setmfact(const Arg *arg) {
   float f;

   if(!arg || !selmon->lt[selmon->sellt]->arrange)
      return;
   f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
   if(f < 0.1 || f > 0.9)
      return;
   selmon->mfact = f;
   arrange(selmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xab03
movq 0xdb16(%rip), %rax      # 0x18600
movq 0xdb0f(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
jne 0xab08
jmp 0xabb9
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x74f4(%rip), %xmm0     # 0x12010
ucomisd %xmm1, %xmm0
jbe 0xab41
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq 0xdacf(%rip), %rax      # 0x18600
addss 0x10(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xab5e
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x74bb(%rip), %xmm1     # 0x12010
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x749b(%rip), %xmm0     # 0x12018
ucomisd %xmm1, %xmm0
ja 0xab9a
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x748c(%rip), %xmm1     # 0x12020
ucomisd %xmm1, %xmm0
jbe 0xab9c
jmp 0xabb9
movss -0xc(%rbp), %xmm0
movq 0xda58(%rip), %rax      # 0x18600
movss %xmm0, 0x10(%rax)
movq 0xda4c(%rip), %rdi      # 0x18600
callq 0xbf30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: zoom
void
zoom(const Arg *arg) {
   Client *c = selmon->sel;
   if(!c) return;

   /* we can zoom floating stuff too */
   if(c->isfloating && !c->isfixed)
      c->isfloating = False;

   if(!selmon->lt[selmon->sellt]->arrange
         || (selmon->sel && selmon->sel->isfloating))
      return;

   detach(c);
   attach(c);
   focus(c);
   arrange(c->mon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xda2d(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xabea
jmp 0xac87
movq -0x10(%rbp), %rax
cmpl $0x0, 0x168(%rax)
je 0xac12
movq -0x10(%rbp), %rax
cmpl $0x0, 0x164(%rax)
jne 0xac12
movq -0x10(%rbp), %rax
movl $0x0, 0x168(%rax)
movq 0xd9e7(%rip), %rax      # 0x18600
movq 0xd9e0(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0xac5a
movq 0xd9c7(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
je 0xac5c
movq 0xd9b6(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
cmpl $0x0, 0x168(%rax)
je 0xac5c
jmp 0xac87
movq -0x10(%rbp), %rdi
callq 0xf910
movq -0x10(%rbp), %rdi
callq 0x109b0
movq -0x10(%rbp), %rdi
callq 0xc2d0
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: killclient
void
killclient(const Arg *arg) {
   XEvent ev;
   wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
   wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);

   if(!selmon->sel)
      return;
   if(isprotodel(selmon->sel)) {
      ev.type = ClientMessage;
      ev.xclient.window = selmon->sel->win;
      ev.xclient.message_type = wmatom[WMProtocols];
      ev.xclient.format = 32;
      ev.xclient.data.l[0] = wmatom[WMDelete];
      ev.xclient.data.l[1] = CurrentTime;
      XSendEvent(dpy, selmon->sel->win, False, NoEventMask, &ev);
   }
   else {
      XGrabServer(dpy);
      XSetErrorHandler(xerrordummy);
      XSetCloseDownMode(dpy, DestroyAll);
      XKillClient(dpy, selmon->sel->win);
      XSync(dpy, False);
      XSetErrorHandler(xerror);
      XUngrabServer(dpy);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq 0xd972(%rip), %rdi      # 0x18618
leaq 0x7684(%rip), %rsi      # 0x12331
xorl %edx, %edx
callq 0x55f0
movq %rax, 0xd975(%rip)      # 0x18630
movq 0xd956(%rip), %rdi      # 0x18618
leaq 0x7675(%rip), %rsi      # 0x1233e
xorl %edx, %edx
callq 0x55f0
movq %rax, 0xd961(%rip)      # 0x18638
movq 0xd922(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
jne 0xaced
jmp 0xadfd
movq 0xd90c(%rip), %rax      # 0x18600
movq 0x80(%rax), %rdi
callq 0x10ca0
cmpl $0x0, %eax
je 0xad90
movl $0x21, -0xc8(%rbp)
movq 0xd8e6(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq 0xd8fa(%rip), %rax      # 0x18630
movq %rax, -0xa0(%rbp)
movl $0x20, -0x98(%rbp)
movq 0xd8ea(%rip), %rax      # 0x18638
movq %rax, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq 0xd8b1(%rip), %rdi      # 0x18618
movq 0xd892(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xc8(%rbp), %r8
callq 0x5500
jmp 0xadfd
movq 0xd881(%rip), %rdi      # 0x18618
callq 0x5100
leaq 0x4bdd(%rip), %rdi      # 0xf980
callq 0x5690
movq 0xd869(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x5170
movq 0xd85b(%rip), %rdi      # 0x18618
movq 0xd83c(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
callq 0x57a0
movq 0xd83a(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
leaq -0x488c(%rip), %rdi     # 0x6560
callq 0x5690
movq 0xd820(%rip), %rdi      # 0x18618
callq 0x53a0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: togglesticky
void togglesticky(const Arg *arg) {
   Client *c;
   if(!(c = selmon->sel))
      return;
   if(c->iszombie)
      return;

   c->issticky = !c->issticky;
   if(!c->issticky)
      c->tags = c->mon->tagset[c->mon->seltags];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0xd301(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xb312
jmp 0xb374
movq -0x10(%rbp), %rax
cmpl $0x0, 0x17c(%rax)
je 0xb321
jmp 0xb374
movq -0x10(%rbp), %rax
cmpl $0x0, 0x180(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x180(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xb374
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
movl 0x58(%rcx), %ecx
movl 0x60(%rax,%rcx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x15c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: view
void
view(const Arg *arg) {
   if((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
      return;
   selmon->seltags ^= 1; /* toggle sel tagset */
   if(arg->ui & TAGMASK)
      selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
   arrange(selmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movq 0xd262(%rip), %rcx      # 0x18600
movq 0xd25b(%rip), %rdx      # 0x18600
movl 0x58(%rdx), %edx
cmpl 0x60(%rcx,%rdx,4), %eax
jne 0xb3b0
jmp 0xb3fd
movq 0xd249(%rip), %rax      # 0x18600
movl 0x58(%rax), %ecx
xorl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x0, %eax
je 0xb3f1
movq -0x8(%rbp), %rax
movl (%rax), %edx
andl $0x1ff, %edx            # imm = 0x1FF
movq 0xd21d(%rip), %rax      # 0x18600
movq 0xd216(%rip), %rcx      # 0x18600
movl 0x58(%rcx), %ecx
movl %edx, 0x60(%rax,%rcx,4)
movq 0xd208(%rip), %rdi      # 0x18600
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: focusmonitor
void focusmonitor(const Arg *arg){
   Monitor *m = NULL;
   if(!mons->next)
      return;
   if((m = dirtomon(arg->i)) == selmon)
      return;
   unfocus(selmon->sel, True);
   selmon = m;
   focus(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq 0xd16d(%rip), %rax      # 0x185f8
cmpq $0x0, 0x90(%rax)
jne 0xb497
jmp 0xb4dd
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x10d60
movq %rax, -0x10(%rbp)
cmpq 0xd153(%rip), %rax      # 0x18600
jne 0xb4b1
jmp 0xb4dd
movq 0xd148(%rip), %rax      # 0x18600
movq 0x80(%rax), %rdi
movl $0x1, %esi
callq 0xc5a0
movq -0x10(%rbp), %rax
movq %rax, 0xd12c(%rip)      # 0x18600
xorl %eax, %eax
movl %eax, %edi
callq 0xc2d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: nextlayout
void
nextlayout(const Arg *arg) {
   Layout *l;
   for (l=(Layout *)layouts;l != selmon->lt[selmon->sellt];l++);
   if (l->symbol && (l + 1)->symbol)
      setlayout(&((Arg) { .v = (l + 1) }));
   else
      setlayout(&((Arg) { .v = layouts }));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xaccd(%rip), %rax      # 0x16230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xd08e(%rip), %rcx      # 0x18600
movq 0xd087(%rip), %rdx      # 0x18600
movl 0x5c(%rdx), %edx
cmpq 0xa0(%rcx,%rdx,8), %rax
je 0xb596
jmp 0xb588
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0xb567
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb5c3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb5c3
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10e20
jmp 0xb5d7
leaq 0xac66(%rip), %rax      # 0x16230
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10e20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: prevlayout
void
prevlayout(const Arg *arg) {
   Layout *l;
   for (l=(Layout *)layouts;l != selmon->lt[selmon->sellt];l++);
   if (l != layouts && (l - 1)->symbol)
      setlayout(&((Arg) { .v = (l - 1) }));
   else
      setlayout(&((Arg) { .v = &layouts[LENGTH(layouts) - 2] }));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xac3d(%rip), %rax      # 0x16230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xcffe(%rip), %rcx      # 0x18600
movq 0xcff7(%rip), %rdx      # 0x18600
movl 0x5c(%rdx), %edx
cmpq 0xa0(%rcx,%rdx,8), %rax
je 0xb626
jmp 0xb618
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0xb5f7
leaq 0xac03(%rip), %rax      # 0x16230
cmpq %rax, -0x10(%rbp)
je 0xb655
movq -0x10(%rbp), %rax
cmpq $0x0, -0x10(%rax)
je 0xb655
movq -0x10(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10e20
jmp 0xb66d
leaq 0xabd4(%rip), %rax      # 0x16230
addq $0x78, %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10e20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: cyclezoom
void
cyclezoom(const Arg *arg)
{
   Client *c = selmon->clients;
   if(!c)
      return;

   if(!selmon->lt[selmon->sellt]->arrange
         || selmon->lt[selmon->sellt]->arrange == monocle
         || (selmon->sel && selmon->sel->isfloating))
      return;

   detach(c);
   if(c->next) focus(c->next);
   attachend(c);
   arrange(c->mon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xcf6d(%rip), %rax      # 0x18600
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb6a7
jmp 0xb757
movq 0xcf52(%rip), %rax      # 0x18600
movq 0xcf4b(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0xb715
movq 0xcf32(%rip), %rax      # 0x18600
movq 0xcf2b(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
leaq -0x3857(%rip), %rcx     # 0x7e90
cmpq %rcx, 0x10(%rax)
je 0xb715
movq 0xcf0c(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
je 0xb717
movq 0xcefb(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
cmpl $0x0, 0x168(%rax)
je 0xb717
jmp 0xb757
movq -0x10(%rbp), %rdi
callq 0xf910
movq -0x10(%rbp), %rax
cmpq $0x0, 0x190(%rax)
je 0xb73e
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rdi
callq 0xc2d0
movq -0x10(%rbp), %rdi
callq 0x10f00
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: togglefloating
void
togglefloating(const Arg *arg) {
   if(!selmon->sel)
      return;

   if(!selmon->sel->isfloating && !selmon->sel->isfixed)
      resizeclient(selmon->sel, selmon->sel->x, selmon->sel->y,
            selmon->sel->fw, selmon->sel->fh);

   selmon->sel->isfloating = !selmon->sel->isfloating ||
      selmon->sel->isfixed;

   arrange(selmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xce8d(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
jne 0xb782
jmp 0xb873
movq 0xce77(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
cmpl $0x0, 0x168(%rax)
jne 0xb814
movq 0xce60(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
cmpl $0x0, 0x164(%rax)
jne 0xb814
movq 0xce49(%rip), %rax      # 0x18600
movq 0x80(%rax), %rdi
movq 0xce3b(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl 0x108(%rax), %esi
movq 0xce27(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl 0x10c(%rax), %edx
movq 0xce13(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl 0x128(%rax), %ecx
movq 0xcdff(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl 0x12c(%rax), %r8d
callq 0x8660
movq 0xcde5(%rip), %rax      # 0x18600
movq 0x80(%rax), %rcx
movb $0x1, %al
cmpl $0x0, 0x168(%rcx)
movb %al, -0x9(%rbp)
je 0xb84b
movq 0xcdc9(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
cmpl $0x0, 0x164(%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq 0xcda6(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl %ecx, 0x168(%rax)
movq 0xcd92(%rip), %rdi      # 0x18600
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: togglelayout
void
togglelayout(const Arg *arg) {
   int tmp = selmon->sellt;
   if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
      tmp = selmon->sellt ^ 1;
   if(arg && arg->v)
   {
      if(!selmon->olt)
      {  selmon->olt                = selmon->lt[selmon->sellt]; selmon->sellt = tmp;
         selmon->lt[selmon->sellt]  = (Layout *)arg->v;        }
      else
      { selmon->sellt = tmp;
         selmon->lt[selmon->sellt]   = selmon->olt;
         selmon->olt                 = NULL;
      }
   }

   strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
   if(selmon->sel)
      arrange(selmon);
   else
      drawbar(selmon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xcd6d(%rip), %rax      # 0x18600
movl 0x5c(%rax), %eax
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb8cc
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb8cc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xcd48(%rip), %rcx      # 0x18600
movq 0xcd41(%rip), %rdx      # 0x18600
movl 0x5c(%rdx), %edx
cmpq 0xa0(%rcx,%rdx,8), %rax
je 0xb8dc
movq 0xcd2d(%rip), %rax      # 0x18600
movl 0x5c(%rax), %eax
xorl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb9a4
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb9a4
movq 0xcd04(%rip), %rax      # 0x18600
cmpq $0x0, 0xb0(%rax)
jne 0xb95c
movq 0xccf3(%rip), %rax      # 0x18600
movq 0xccec(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rcx
movq 0xccda(%rip), %rax      # 0x18600
movq %rcx, 0xb0(%rax)
movl -0xc(%rbp), %ecx
movq 0xccc9(%rip), %rax      # 0x18600
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq 0xccb8(%rip), %rax      # 0x18600
movq 0xccb1(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq %rdx, 0xa0(%rax,%rcx,8)
jmp 0xb9a2
movl -0xc(%rbp), %ecx
movq 0xcc9a(%rip), %rax      # 0x18600
movl %ecx, 0x5c(%rax)
movq 0xcc90(%rip), %rax      # 0x18600
movq 0xb0(%rax), %rdx
movq 0xcc82(%rip), %rax      # 0x18600
movq 0xcc7b(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq %rdx, 0xa0(%rax,%rcx,8)
movq 0xcc69(%rip), %rax      # 0x18600
movq $0x0, 0xb0(%rax)
jmp 0xb9a4
movq 0xcc55(%rip), %rdi      # 0x18600
movq 0xcc4e(%rip), %rax      # 0x18600
movq 0xcc47(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
callq 0x5620
movq 0xcc27(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
je 0xb9f1
movq 0xcc16(%rip), %rdi      # 0x18600
callq 0xbf30
jmp 0xb9fd
movq 0xcc08(%rip), %rdi      # 0x18600
callq 0x8b10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: togglemenu
void
togglemenu(const Arg *arg) {
   if(!menu)
      openmenu(&rootMenu[0]);
   else
      closemenus();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xc98c(%rip)      # 0x18610
jne 0xbc94
leaq 0xa913(%rip), %rdi      # 0x165a0
callq 0x10f80
jmp 0xbc99
callq 0xf690
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: toggleview
void
toggleview(const Arg *arg) {
   unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);

   if(newtagset) {
      selmon->tagset[selmon->seltags] = newtagset;
      arrange(selmon);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc94d(%rip), %rax      # 0x18600
movq 0xc946(%rip), %rcx      # 0x18600
movl 0x58(%rcx), %ecx
movl 0x60(%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xbcfc
movl -0xc(%rbp), %edx
movq 0xc91e(%rip), %rax      # 0x18600
movq 0xc917(%rip), %rcx      # 0x18600
movl 0x58(%rcx), %ecx
movl %edx, 0x60(%rax,%rcx,4)
movq 0xc909(%rip), %rdi      # 0x18600
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: toggletag
void
toggletag(const Arg *arg) {
   unsigned int newtags;

   if(!selmon->sel)
      return;
   newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
   if(newtags) {
      selmon->sel->tags = newtags;
      arrange(selmon);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc8dd(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
jne 0xbd2f
jmp 0xbd7d
movq 0xc8ca(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl 0x15c(%rax), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xbd7d
movl -0xc(%rbp), %ecx
movq 0xc89c(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movl %ecx, 0x15c(%rax)
movq 0xc888(%rip), %rdi      # 0x18600
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: restart
void
restart(const Arg *arg)
{
   fprintf(stderr, "restarting dwm..");
   systray_freeicons();
   if (arg->v) {
      execvp(((char **)arg->v)[0], (char **)arg->v);
   } else {
      execlp("dwm", "dwm", "-r", NULL);
   }
   systray_acquire();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xb245(%rip), %rax      # 0x16fe8
movq (%rax), %rdi
leaq 0x737d(%rip), %rsi      # 0x1312a
movb $0x0, %al
callq 0x5740
callq 0xa150
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbddb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5130
jmp 0xbdf7
leaq 0x6901(%rip), %rsi      # 0x126e3
leaq 0x6498(%rip), %rdx      # 0x12281
xorl %eax, %eax
movl %eax, %ecx
movq %rsi, %rdi
movb $0x0, %al
callq 0x51f0
callq 0x6d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)