LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: grid
void
grid(Monitor *m) {
   unsigned int i, n, cx, cy, cw, ch, aw, ah, cols, rows;
   Client *c;

   for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next))
      n++;

   /* grid dimensions */
   for(rows = 0; rows <= n/2; rows++)
      if(rows*rows >= n)
         break;
   cols = (rows && (rows - 1) * rows >= n) ? rows - 1 : rows;

   /* window geoms (cell height/width) */
   ch = m->wh / (rows ? rows : 1);
   cw = m->ww / (cols ? cols : 1);
   for(i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next)) {
      cx = m->wx + (i / rows) * cw;
      cy = m->wy + (i % rows) * ch;
      /* adjust height/width of last row/column's windows */
      ah = ((i + 1) % rows == 0) ? m->wh - ch * rows : 0;
      aw = (i >= rows * (cols - 1)) ? m->ww - cw * cols : 0;
      resize(c, cx, cy, cw - 2 * c->bw + aw, ch - 2 * c->bw + ah, False);
      i++;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x732d
movq %rax, %r14
xorl %ebp, %ebp
testq %rax, %rax
je 0x6fdc
movq %r14, %rax
incl %ebp
movq 0x190(%rax), %rdi
callq 0x732d
testq %rax, %rax
jne 0x6fc9
movl %ebp, %eax
shrl %eax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incl %r13d
cmpl %eax, %r13d
ja 0x6ff9
movl %r13d, %ecx
imull %r13d, %ecx
cmpl %ebp, %ecx
jb 0x6fe6
testl %r13d, %r13d
je 0x700d
leal -0x1(%r13), %r8d
movl %r8d, %eax
imull %r13d, %eax
cmpl %ebp, %eax
jae 0x7010
movl %r13d, %r8d
movl 0x40(%rbx), %ecx
movl 0x44(%rbx), %eax
cmpl $0x1, %r13d
movl %r13d, %esi
adcl $0x0, %esi
xorl %edi, %edi
xorl %edx, %edx
divl %esi
movl %eax, %ebp
cmpl $0x1, %r8d
movl %r8d, %esi
adcl $0x0, %esi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
testq %r14, %r14
je 0x70ec
movq %r8, %r9
movl %eax, %r15d
movl %ebp, %eax
imull %r13d, %eax
movl %eax, 0x8(%rsp)
leal -0x1(%r8), %eax
imull %r13d, %eax
movl %eax, 0xc(%rsp)
imull %r15d, %r9d
movq %r9, 0x10(%rsp)
movl %edi, %eax
xorl %edx, %edx
divl %r13d
movl %eax, %esi
movl %edx, %r9d
xorl %ecx, %ecx
leal 0x1(%rdi), %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %r13d
movl $0x0, %r8d
testl %edx, %edx
jne 0x7093
movl 0x44(%rbx), %r8d
subl 0x8(%rsp), %r8d
imull %r15d, %esi
addl 0x38(%rbx), %esi
imull %ebp, %r9d
addl 0x3c(%rbx), %r9d
cmpl 0xc(%rsp), %edi
jb 0x70af
movl 0x40(%rbx), %ecx
subl 0x10(%rsp), %ecx
movl 0x150(%r14), %eax
addl %eax, %eax
addl %r15d, %ecx
subl %eax, %ecx
addl %ebp, %r8d
subl %eax, %r8d
movq %r14, %rdi
movl %r9d, %edx
xorl %r9d, %r9d
callq 0x7373
movq 0x190(%r14), %rdi
callq 0x732d
movq %rax, %r14
movl %r12d, %edi
testq %rax, %rax
jne 0x7066
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: bstack
void
bstack(Monitor *m) {
   int x, y, h, w, mh;
   unsigned int i, n;
   Client *c;

   for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
   if(n == 0)
      return;
   /* master */
   c = nexttiled(m->clients);
   mh = m->mfact * m->wh;
   resize(c, m->wx, m->wy, m->ww - 2 * c->bw, (n == 1 ? m->wh : mh) - 2 * c->bw, False);
   if(--n == 0)
      return;
   /* tile stack */
   x = m->wx;
   y = (m->wy + mh > c->y + c->h) ? c->y + c->h + 2 * c->bw : m->wy + mh;
   w = m->ww / n;
   h = (m->wy + mh > c->y + c->h) ? m->wy + m->wh - y : m->wh - mh;
   if(w < m->bh)
      w = m->ww;
   for(i = 0, c = nexttiled(c->next); c; c = nexttiled(c->next), i++) {
      resize(c, x, y, /* remainder */ ((i + 1 == n)
               ? m->wx + m->ww - x - 2 * c->bw : w - 2 * c->bw), h - 2 * c->bw, False);
      if(w != m->ww)
         x = c->x + WIDTH(c);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
callq 0x732d
movq %rax, %r14
xorl %r13d, %r13d
testq %rax, %rax
je 0x7134
movq %r14, %rax
movq 0x190(%rax), %rdi
callq 0x732d
incl %r13d
testq %rax, %rax
jne 0x7120
testl %r13d, %r13d
je 0x726d
movl 0x44(%rbx), %r8d
cvtsi2ss %r8d, %xmm0
mulss 0x10(%rbx), %xmm0
cvttss2si %xmm0, %ebp
movl 0x38(%rbx), %esi
movl 0x3c(%rbx), %edx
movl 0x40(%rbx), %ecx
movl 0x150(%r14), %eax
addl %eax, %eax
subl %eax, %ecx
cmpl $0x1, %r13d
cmovnel %ebp, %r8d
subl %eax, %r8d
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x7373
movl %r13d, %edi
decl %edi
je 0x726d
movl 0x3c(%rbx), %esi
leal (%rsi,%rbp), %r8d
movl 0x114(%r14), %r9d
addl 0x10c(%r14), %r9d
movl %r8d, %r10d
cmpl %r9d, %r8d
jle 0x71ac
movl 0x150(%r14), %eax
leal (%r9,%rax,2), %r10d
movl 0x38(%rbx), %r12d
movl 0x40(%rbx), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movl %eax, %r15d
movl %r10d, 0x4(%rsp)
subl %r10d, %esi
negl %ebp
cmpl %r9d, %r8d
cmovgl %esi, %ebp
addl 0x44(%rbx), %ebp
cmpl 0x24(%rbx), %eax
cmovll %ecx, %r15d
movq 0x190(%r14), %rdi
callq 0x732d
testq %rax, %rax
je 0x726d
movq %rax, %r14
addl $-0x2, %r13d
subl $0x1, %r13d
jae 0x720b
movl 0x38(%rbx), %ecx
movl 0x150(%r14), %eax
addl 0x40(%rbx), %ecx
leal (%r12,%rax,2), %eax
jmp 0x7217
movl 0x150(%r14), %eax
addl %eax, %eax
movl %r15d, %ecx
subl %eax, %ecx
movl 0x4(%rsp), %edx
movl 0x150(%r14), %eax
addl %eax, %eax
movl %ebp, %r8d
subl %eax, %r8d
movq %r14, %rdi
movl %r12d, %esi
xorl %r9d, %r9d
callq 0x7373
cmpl 0x40(%rbx), %r15d
je 0x7259
movl 0x110(%r14), %eax
movl 0x150(%r14), %ecx
addl 0x108(%r14), %eax
leal (%rax,%rcx,2), %r12d
movq 0x190(%r14), %rdi
callq 0x732d
movq %rax, %r14
testq %rax, %rax
jne 0x71f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x72c0
cmpl $0x0, 0x180(%rax)
jne 0x72ad
movq 0x1a0(%rax), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rax)
je 0x72b7
cmpl $0x1, 0x170(%rax)
adcl $0x0, %ecx
movq 0x190(%rax), %rax
jmp 0x7289
testl %ecx, %ecx
je 0x72da
leaq 0x6054(%rip), %rdx      # 0xd31f
movl $0x10, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50a0
movq 0x78(%rbx), %rdi
callq 0x732d
testq %rax, %rax
je 0x7325
movq %rax, %r14
movl 0x38(%rbx), %esi
movl 0x3c(%rbx), %edx
movl 0x40(%rbx), %ecx
movl 0x150(%r14), %eax
addl %eax, %eax
subl %eax, %ecx
movl 0x44(%rbx), %r8d
subl %eax, %r8d
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x7373
movq 0x190(%r14), %rdi
callq 0x732d
movq %rax, %r14
testq %rax, %rax
jne 0x72eb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x168(%rdi)
je 0x75e0
cmpl $0x0, 0x160(%rbx)
jne 0x75e0
movq 0x110(%rbx), %rax
movq %rax, 0x128(%rbx)
movl 0x108(%rbx), %eax
movl %eax, 0x118(%rbx)
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movl %esi, 0x108(%rbx)
movl 0x10c(%rbx), %esi
movl %esi, 0x11c(%rbx)
movl %edx, 0x4(%rax)
movl %edx, 0x10c(%rbx)
movl 0x110(%rbx), %edx
movl %edx, 0x120(%rbx)
movl %ecx, 0x8(%rax)
movl %ecx, 0x110(%rbx)
movl 0x114(%rbx), %ecx
movl %ecx, 0x124(%rbx)
movl %r8d, 0xc(%rax)
movl %r8d, 0x114(%rbx)
movl 0x150(%rbx), %ecx
movl %ecx, 0x10(%rax)
movq 0xbe3e(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl $0x1f, %edx
movq %rax, %rcx
callq 0x50d0
movq %rbx, %rdi
callq 0x767a
movq 0xbe1b(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x58, %rsp
movq %rsp, %r8
movl $0x16, (%r8)
movq 0xbdf9(%rip), %rax      # 0x13488
movq %rax, 0x18(%r8)
movq 0x1a8(%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movl 0x108(%rdi), %ecx
movl %ecx, 0x30(%r8)
movl 0x10c(%rdi), %ecx
movl %ecx, 0x34(%r8)
movl 0x110(%rdi), %ecx
movl %ecx, 0x38(%r8)
movl 0x114(%rdi), %ecx
movl %ecx, 0x3c(%r8)
movl 0x150(%rdi), %ecx
movl %ecx, 0x40(%r8)
movq $0x0, 0x48(%r8)
movl $0x0, 0x50(%r8)
movl $0x20000, %ecx          # imm = 0x20000
movq %rax, %rdi
xorl %edx, %edx
callq 0x54f0
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0xbd69(%rip), %rax      # 0x13468
testq %rax, %rax
je 0x7729
movl 0x38(%rax), %ecx
cmpl %edi, %ecx
jg 0x7720
addl 0x40(%rax), %ecx
cmpl %edi, %ecx
jle 0x7720
movl 0x3c(%rax), %ecx
cmpl %esi, %ecx
jg 0x7720
addl 0x44(%rax), %ecx
cmpl %esi, %ecx
jg 0x7730
movq 0x90(%rax), %rax
jmp 0x76ff
movq 0xbd40(%rip), %rax      # 0x13470
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x77f2
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rsi
movb $0x0, (%rdx)
movq 0xbd23(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x52f0
cmpq $0x0, 0x18(%r15)
je 0x77f2
cmpq $0x1f, 0x20(%rsp)
jne 0x7794
movq 0x18(%rsp), %rsi
leal -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x5610
jmp 0x77db
movq 0xbced(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x5240
testl %eax, %eax
js 0x77db
cmpl $0x0, 0xc(%rsp)
jle 0x77db
movq 0x10(%rsp), %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x77db
leal -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x5610
movq %r15, %rdi
callq 0x5580
movslq %r14d, %rax
movb $0x0, -0x1(%rbx,%rax)
movq 0x18(%rsp), %rdi
callq 0x5070
movl $0x1, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %eax
leal 0x1(%rax), %ecx
movq %rsp, %rsi
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %rsi
movq %rsi, %rsp
movb (%rdi), %r9b
testb %r9b, %r9b
sete %dl
testl %eax, %eax
sete %r8b
xorl %ecx, %ecx
orb %dl, %r8b
jne 0x82dd
movl $0x1, %r8d
movl %eax, %edx
cmpb $0xc, %r9b
ja 0x82bb
decl %edx
jmp 0x82c4
movl %ecx, %r10d
movb %r9b, (%rsi,%r10)
incl %ecx
movb (%rdi,%r8), %r9b
testb %r9b, %r9b
je 0x82d9
leaq 0x1(%r8), %r10
cmpl %eax, %r8d
movq %r10, %r8
jb 0x82b1
movl %ecx, %ecx
jmp 0x82df
movl %eax, %edx
movb $0x0, (%rsi,%rcx)
movq 0xb356(%rip), %rdi      # 0x13640
testq %rdi, %rdi
je 0x8303
leaq -0x10(%rbp), %rbx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x55f0
movzwl 0x4(%rbx), %eax
jmp 0x830f
movq 0xb33e(%rip), %rdi      # 0x13648
callq 0x54b0
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq 0xaf33(%rip), %rbx      # 0x13490
testq %rbx, %rbx
je 0x85b0
movq 0xaf1f(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5350
movq 0xaf10(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56f0
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rbx
testq %r14, %r14
jne 0x8562
movq 0xaed1(%rip), %rdi      # 0x13488
movq 0xaf22(%rip), %rsi      # 0x134e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54d0
movq 0xaeba(%rip), %rdi      # 0x13488
movq 0xaec3(%rip), %rsi      # 0x13498
callq 0x5300
movq 0xaea7(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movl $0x21, (%r13)
movq 0xae6e(%rip), %rdi      # 0x13488
movq %rdx, %rsi
xorl %edx, %edx
callq 0x55e0
movq %rax, 0x28(%r13)
movq %r15, 0x20(%r13)
movl $0x20, 0x30(%r13)
movq $0x0, 0x38(%r13)
movq %r14, 0x40(%r13)
movq %rbx, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r13)
movq 0xae35(%rip), %rdi      # 0x13488
movl $0x20000, %ecx          # imm = 0x20000
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %r8
callq 0x54f0
movq 0xae1c(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x0, 0xb185(%rip)      # 0x13818
movq 0xadee(%rip), %rdi      # 0x13488
callq 0x55d0
movq %rax, %rbx
xorl %ebp, %ebp
movl (%rbx), %eax
testl %eax, %eax
je 0x86ed
movl $0x1, %r14d
movl %ebp, %ecx
shll %cl, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r15d, %eax
movb (%rcx,%rax), %r12b
movq 0xadbb(%rip), %rdi      # 0x13488
movl $0xff7f, %esi           # imm = 0xFF7F
callq 0x5630
cmpb %al, %r12b
jne 0x86e3
movl %r14d, 0xb135(%rip)     # 0x13818
incl %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jb 0x86b8
incl %ebp
cmpl $0x8, %ebp
jne 0x86a4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x51c0
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq 0xab06(%rip), %rdi      # 0x13470
testq %rdi, %rdi
je 0x89a9
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x89aa
cmpl $0x0, 0x180(%rcx)
jne 0x8997
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x89a0
cmpl $0x0, 0x160(%rcx)
jne 0x89a9
movq 0x190(%rcx), %rcx
jmp 0x8973
retq
testq %rax, %rax
je 0x89c0
movl (%rax), %ecx
cmpl $-0x1, %ecx
je 0x89c0
movl %ecx, 0x6c(%rdi)
movl (%rax), %esi
jmp 0x982c
movl 0x68(%rdi), %eax
movl %eax, 0x6c(%rdi)
xorl %esi, %esi
testl %eax, %eax
sete %sil
jmp 0x982c
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: focusstack
void
focusstack(const Arg *arg) {
   Client *c = NULL, *i;

   if(!selmon)
      return;
   if(!selmon->sel)
      return;
   if(arg->i > 0) {
      for(c = selmon->sel->next; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
      if(!c)
         for(c = selmon->clients; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
   }
   else {
      for(i = selmon->clients; i != selmon->sel; i = i->next)
         if(ISVISIBLE(i) && !i->iswidget)
            c = i;
      if(!c)
         for(; i; i = i->next)
            if(ISVISIBLE(i) && !i->iswidget)
               c = i;
   }
   if(c) {
      focus(c);
      restack(selmon);
   }
}

// Assembly:
pushq %rax
movq 0xaa95(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x8b21
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x8b21
cmpl $0x0, (%rdi)
jle 0x8a80
movq 0x190(%rcx), %rdi
testq %rdi, %rdi
je 0x8a3e
cmpl $0x0, 0x180(%rdi)
jne 0x8a28
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0x8a35
cmpl $0x0, 0x170(%rdi)
je 0x8b0a
movq 0x190(%rdi), %rdi
jmp 0x8a04
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0x8b08
cmpl $0x0, 0x180(%rdi)
jne 0x8a6a
movq 0x1a0(%rdi), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rdi)
je 0x8a77
cmpl $0x0, 0x170(%rdi)
je 0x8b0a
movq 0x190(%rdi), %rdi
jmp 0x8a42
movq 0x78(%rax), %rax
xorl %edi, %edi
cmpq %rcx, %rax
je 0x8abe
cmpl $0x0, 0x180(%rax)
jne 0x8aaa
movq 0x1a0(%rax), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rax)
je 0x8ab5
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
movq 0x190(%rax), %rax
jmp 0x8a86
testq %rdi, %rdi
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x8b0a
xorl %edi, %edi
cmpl $0x0, 0x180(%rax)
jne 0x8aef
movq 0x1a0(%rax), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rax)
je 0x8afa
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x8ad0
jmp 0x8b0a
xorl %edi, %edi
testq %rdi, %rdi
je 0x8b21
callq 0x9b58
movq 0xa955(%rip), %rdi      # 0x13470
popq %rax
jmp 0xa456
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x8b91
movq %rdi, %rax
movq 0xa93e(%rip), %rdi      # 0x13470
movl 0x5c(%rdi), %ecx
movq 0xa0(%rdi,%rcx,8), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x8b91
movss (%rax), %xmm0
movss 0x44d4(%rip), %xmm1     # 0xd024
ucomiss %xmm0, %xmm1
jbe 0x8b5c
movss 0x10(%rdi), %xmm1
jmp 0x8b64
movss 0x44bc(%rip), %xmm1     # 0xd020
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x4499(%rip), %xmm2     # 0xd010
ucomisd %xmm1, %xmm2
ja 0x8b91
ucomisd 0x4493(%rip), %xmm1     # 0xd018
ja 0x8b91
movss %xmm0, 0x10(%rdi)
jmp 0x98ef
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0xa8d6(%rip), %rax      # 0x13470
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x8bdd
cmpl $0x0, 0x168(%rbx)
je 0x8bc2
cmpl $0x0, 0x164(%rbx)
jne 0x8bc2
movl $0x0, 0x168(%rbx)
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x8bdd
cmpl $0x0, 0x168(%rbx)
je 0x8bdf
popq %rbx
retq
movq 0x1a0(%rbx), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x8c01
leaq 0x190(%rdx), %rcx
cmpq %rbx, %rdx
jne 0x8bea
movq 0x190(%rbx), %rcx
movq %rcx, (%rax)
movq 0x1a0(%rbx), %rax
movq 0x78(%rax), %rcx
movq %rcx, 0x190(%rbx)
movq %rbx, 0x78(%rax)
movq %rbx, %rdi
callq 0x9b58
movq 0x1a0(%rbx), %rdi
popq %rbx
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xc8, %rsp
movq 0xa841(%rip), %rdi      # 0x13488
leaq 0x44e4(%rip), %rsi      # 0xd132
xorl %edx, %edx
callq 0x55e0
movq %rax, 0xa844(%rip)      # 0x134a0
movq 0xa825(%rip), %rdi      # 0x13488
leaq 0x44d5(%rip), %rsi      # 0xd13f
xorl %edx, %edx
callq 0x55e0
movq %rax, 0xa830(%rip)      # 0x134a8
movq 0xa7f1(%rip), %rax      # 0x13470
movq 0x80(%rax), %r14
testq %r14, %r14
je 0x8dfa
movq 0xa7f2(%rip), %rdi      # 0x13488
leaq 0x44a2(%rip), %rsi      # 0xd13f
xorl %edx, %edx
callq 0x55e0
movq %rax, 0xa7fd(%rip)      # 0x134a8
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq 0xa7ca(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
leaq 0x4(%rsp), %rcx
movq %rbx, %rdx
callq 0x56c0
testl %eax, %eax
setne %al
movq (%rbx), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8d8d
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
jae 0x8d02
movl %ecx, 0x4(%rsp)
callq 0x5070
jmp 0x8d8d
movq 0xa79f(%rip), %rax      # 0x134a8
movslq %ecx, %rcx
xorl %ebx, %ebx
xorl %edx, %edx
cmpq %rax, (%rdi,%rcx,8)
sete %dl
addl %edx, %ebx
addq $-0x1, %rcx
jb 0x8d0e
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
callq 0x5070
testl %ebx, %ebx
je 0x8d8d
leaq 0x8(%rsp), %r8
movl $0x21, (%r8)
movq 0xa72d(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
movq %rsi, 0x20(%r8)
movq 0xa744(%rip), %rax      # 0x134a0
movq %rax, 0x28(%r8)
movl $0x20, 0x30(%r8)
movq 0xa739(%rip), %rax      # 0x134a8
movq %rax, 0x38(%r8)
movq $0x0, 0x40(%r8)
movq 0xa706(%rip), %rdi      # 0x13488
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54f0
jmp 0x8dfa
movq 0xa6f4(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0x318d(%rip), %rdi      # 0xbf2d
callq 0x5680
movq 0xa6dc(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x5160
movq 0xa6ce(%rip), %rdi      # 0x13488
movq 0xa6af(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
callq 0x57a0
movq 0xa6ad(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x28f3(%rip), %rdi     # 0x64f6
callq 0x5680
movq 0xa693(%rip), %rdi      # 0x13488
callq 0x5390
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0xa302(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x9183
cmpl $0x0, 0x17c(%rax)
je 0x9184
retq
xorl %ecx, %ecx
cmpl $0x0, 0x180(%rax)
sete %cl
movl %ecx, 0x180(%rax)
je 0x9183
movq 0x1a0(%rax), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
movl %ecx, 0x15c(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movl $0x1ff, %ecx            # imm = 0x1FF
movl (%rdi), %esi
andl %ecx, %esi
movq 0xa2b0(%rip), %rdi      # 0x13470
movl 0x58(%rdi), %edx
cmpl 0x60(%rdi,%rdx,4), %esi
jne 0x91ca
retq
xorq $0x1, %rdx
movl %edx, 0x58(%rdi)
andl (%rax), %ecx
je 0x98ef
movl %ecx, 0x60(%rdi,%rdx,4)
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0xa253(%rip), %rax      # 0x13468
cmpq $0x0, 0x90(%rax)
je 0x928f
cmpl $0x0, (%rdi)
movq 0xa247(%rip), %rcx      # 0x13470
jle 0x923e
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
cmovneq %rcx, %rax
movq %rax, %rbx
jmp 0x9263
cmpq %rax, %rcx
je 0x9254
movq %rax, %rbx
movq 0x90(%rax), %rax
cmpq %rcx, %rax
jne 0x9243
jmp 0x9263
movq %rax, %rbx
movq 0x90(%rax), %rax
testq %rax, %rax
jne 0x9254
movq 0xa206(%rip), %rax      # 0x13470
cmpq %rax, %rbx
je 0x928f
movq 0x80(%rax), %rdi
movl $0x1, %esi
callq 0x9d77
movq %rbx, 0xa1e9(%rip)      # 0x13470
xorl %edi, %edi
popq %rbx
jmp 0x9b58
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
movq 0xa167(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rsi
leaq 0x7da5(%rip), %r8       # 0x110c0
movq %rsi, %rcx
subq %r8, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
shrq %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,2), %rax
subq %rcx, %rax
cmpq $0x0, 0x8(%rsi,%rax)
je 0x935f
addq %rax, %rsi
cmpq $0x0, 0x20(%rsi)
je 0x935f
addq $0x18, %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
jmp 0x9367
leaq 0x8(%rsp), %rdi
movq %r8, (%rdi)
callq 0xc92c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x18, %rsp
movq 0xa0f4(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rsi
leaq 0x7d32(%rip), %rax      # 0x110c0
movq %rsi, %rcx
subq %rax, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
shrq %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,2), %rax
testq %rax, %rax
je 0x93cf
subq %rcx, %rax
addq %rax, %rsi
cmpq $0x0, -0x10(%rsi)
je 0x93cf
addq $-0x18, %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
jmp 0x93de
leaq 0x7d62(%rip), %rax      # 0x11138
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xc92c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0xa080(%rip), %rax      # 0x13470
movq 0x78(%rax), %rbx
testq %rbx, %rbx
je 0x9434
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
sete %dl
leaq -0x2199(%rip), %rsi     # 0x727c
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x9434
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x9436
cmpl $0x0, 0x168(%rax)
je 0x9436
popq %rbx
retq
movq 0x1a0(%rbx), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x9458
leaq 0x190(%rdx), %rcx
cmpq %rbx, %rdx
jne 0x9441
movq 0x190(%rbx), %rcx
movq %rcx, (%rax)
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x9473
callq 0x9b58
movq 0x1a0(%rbx), %rdi
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x94a6
movq %rax, %rcx
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x9483
movq %rbx, 0x190(%rcx)
movq $0x0, 0x190(%rbx)
jmp 0x94b1
movq %rax, 0x190(%rbx)
movq %rbx, 0x78(%rdi)
popq %rbx
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x9fb2(%rip), %rax      # 0x13470
movq 0x80(%rax), %rdi
testq %rdi, %rdi
je 0x9520
pushq %rax
cmpl $0x0, 0x168(%rdi)
jne 0x94fb
cmpl $0x0, 0x164(%rdi)
jne 0x94fb
movl 0x108(%rdi), %esi
movl 0x10c(%rdi), %edx
movl 0x128(%rdi), %ecx
movl 0x12c(%rdi), %r8d
callq 0x75b8
movq 0x9f6e(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rax
cmpl $0x0, 0x168(%rax)
je 0x9521
xorl %ecx, %ecx
cmpl $0x0, 0x164(%rax)
setne %cl
jmp 0x9526
retq
movl $0x1, %ecx
movl %ecx, 0x168(%rax)
popq %rax
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x9f36(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
testq %rdi, %rdi
je 0x9554
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x9554
cmpq 0xa0(%rax,%rcx,8), %rdx
je 0x9591
movl %ecx, %edx
xorl $0x1, %edx
testq %rdi, %rdi
je 0x95b4
cmpq $0x0, (%rdi)
je 0x95b4
movq 0xb0(%rax), %rsi
testq %rsi, %rsi
je 0x9595
movl %edx, 0x5c(%rax)
movl %edx, %ecx
movq %rsi, 0xa0(%rax,%rcx,8)
movq 0x9eec(%rip), %rax      # 0x13470
movq $0x0, 0xb0(%rax)
jmp 0x95b4
movl %ecx, %edx
jmp 0x9559
movq 0xa0(%rax,%rcx,8), %rcx
movq %rcx, 0xb0(%rax)
movl %edx, 0x5c(%rax)
movq (%rdi), %rcx
movl %edx, %edx
movq %rcx, 0xa0(%rax,%rdx,8)
movq 0x9eb5(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x5610
cmpq $0x0, 0x80(%rbx)
je 0x95ea
movq %rbx, %rdi
popq %rbx
jmp 0x98ef
movq %rbx, %rdi
popq %rbx
jmp 0x77ff
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: togglefullscreen
void
togglefullscreen( const Arg *arg ) {
   Client *c;

   if(!selmon) return;
   c = selmon->sel;
   if(!c) return;

   if(!c->isfullscreen)
   {
      XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
            PropModeReplace, (unsigned char*)&netatom[NetWMFullscreen], 1);
      c->isfullscreen = True;
      c->oldstate = c->isfloating;
      c->oldbw = c->bw;
      c->bw = 0;
      c->isfloating = 1;
      resizeclient(c, c->mon->ox, c->mon->oy, c->mon->ow, c->mon->oh);
      if(!c->isbelow) XRaiseWindow(dpy, c->win);
   }
   else {
      XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
            PropModeReplace, (unsigned char*)0, 0);
      c->isfullscreen = False;
      c->isfloating = c->oldstate;
      c->bw = c->oldbw;
      c->x = c->oldx;
      c->y = c->oldy;
      c->w = c->oldw;
      c->h = c->oldh;
      resizeclient(c, c->x, c->y, c->w, c->h);
   }
   arrange(c->mon);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9e72(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x96b5
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x96b5
cmpl $0x0, 0x160(%rbx)
movq 0x9e63(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq 0x9e9d(%rip), %rdx      # 0x134d0
je 0x96bd
xorl %r14d, %r14d
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq $0x0
callq 0x5660
addq $0x10, %rsp
movl %r14d, 0x160(%rbx)
movl 0x188(%rbx), %eax
movl %eax, 0x168(%rbx)
movl 0x154(%rbx), %eax
movl %eax, 0x150(%rbx)
movl 0x118(%rbx), %esi
movl 0x11c(%rbx), %edx
movl %esi, 0x108(%rbx)
movl %edx, 0x10c(%rbx)
movl 0x120(%rbx), %ecx
movl %ecx, 0x110(%rbx)
movl 0x124(%rbx), %r8d
movl %r8d, 0x114(%rbx)
movq %rbx, %rdi
callq 0x75b8
jmp 0x974c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %r14d
leaq 0x9e0e(%rip), %rax      # 0x134d8
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %rax
callq 0x5660
addq $0x10, %rsp
movl %r14d, 0x160(%rbx)
movl 0x150(%rbx), %eax
movl 0x168(%rbx), %ecx
movl %ecx, 0x188(%rbx)
movl %eax, 0x154(%rbx)
movl $0x0, 0x150(%rbx)
movl %r14d, 0x168(%rbx)
movq 0x1a0(%rbx), %rax
movl 0x48(%rax), %esi
movl 0x4c(%rax), %edx
movl 0x50(%rax), %ecx
movl 0x54(%rax), %r8d
movq %rbx, %rdi
callq 0x75b8
cmpl $0x0, 0x174(%rbx)
jne 0x974c
movq 0x9d48(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x1a0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: togglemenu
void
togglemenu(const Arg *arg) {
   if(!menu)
      openmenu(&rootMenu[0]);
   else
      closemenus();
}

// Assembly:
cmpq $0x0, 0x9d19(%rip)      # 0x13480
jne 0xbd87
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x9d0d(%rip), %rdi      # 0x13488
movq 0x9ece(%rip), %rsi      # 0x13650
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x14(%rsp), %r10
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rcx, %rdx
movq %rbx, %r8
movq %r14, %r9
pushq %rax
pushq %r10
pushq %r10
callq 0x5620
addq $0x20, %rsp
movl (%rbx), %esi
movl (%r14), %edx
leaq 0x7dde(%rip), %rdi      # 0x115a0
callq 0xb9f4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x9c97(%rip), %rdi      # 0x13470
movl 0x58(%rdi), %ecx
movl 0x60(%rdi,%rcx,4), %edx
movl $0x1ff, %esi            # imm = 0x1FF
andl (%rax), %esi
cmpl %esi, %edx
jne 0x97ec
retq
xorl %edx, %esi
movl %esi, 0x60(%rdi,%rcx,4)
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x9c6f(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x981e
movl 0x15c(%rcx), %edx
movl $0x1ff, %esi            # imm = 0x1FF
andl (%rax), %esi
cmpl %esi, %edx
jne 0x981f
retq
xorl %edx, %esi
movl %esi, 0x15c(%rcx)
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: togglebarm
void
togglebarm(Monitor *m, int toggle)
{
   if(!m) return;
   if(toggle != -1)
   {
      if(m->showbar == toggle) return;
      m->showbar = toggle;
   }
   else
      m->showbar = !m->showbar;
   updatebarpos(m);
   XMoveResizeWindow(dpy, m->barwin, m->bx, m->by, m->bw, m->bh);
   arrange(m);

   if(systray_enable && m->primary)
   {
      XWindowChanges wc;
      if(!m->showbar)
      {
         wc.y = -m->bh;
         XConfigureWindow(dpy, traywin, CWY, &wc);
      }
      else
         if(m->showbar)
         {
            if(topbar)
               wc.y = 0;
            else
               wc.y = sh - m->bh;

            XConfigureWindow(dpy, traywin, CWY, &wc);
            systray_update();
         }
   }
}

// Assembly:
testq %rdi, %rdi
je 0x98ee
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $-0x1, %esi
je 0x984e
cmpl %esi, %eax
jne 0x9856
jmp 0x98e9
xorl %esi, %esi
testl %eax, %eax
sete %sil
movl %esi, 0x68(%rbx)
movq %rbx, %rdi
callq 0x6bab
movq 0x9c20(%rip), %rdi      # 0x13488
movq 0x98(%rbx), %rsi
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
movl 0x20(%rbx), %r8d
movl 0x24(%rbx), %r9d
callq 0x53a0
movq %rbx, %rdi
callq 0x98ef
cmpl $0x0, 0xb8(%rbx)
je 0x98e9
cmpl $0x0, 0x68(%rbx)
je 0x98c4
leaq 0x8(%rsp), %rcx
movl $0x0, 0x4(%rcx)
movq 0x9bdc(%rip), %rdi      # 0x13488
movq 0x9be5(%rip), %rsi      # 0x13498
movl $0x2, %edx
callq 0x50d0
callq 0x996a
jmp 0x98e9
xorl %eax, %eax
subl 0x24(%rbx), %eax
leaq 0x8(%rsp), %rcx
movl %eax, 0x4(%rcx)
movq 0x9bb0(%rip), %rdi      # 0x13488
movq 0x9bb9(%rip), %rsi      # 0x13498
movl $0x2, %edx
callq 0x50d0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: arrange
void
arrange(Monitor *m) {
   if(m)
      showhide(m->stack);
   else for(m = mons; m; m = m->next)
      showhide(m->stack);
   focus(NULL);
   if(m)
      arrangemon(m);
   else for(m = mons; m; m = m->next)
      arrangemon(m);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9922
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
callq 0x9a7c
xorl %edi, %edi
callq 0x9b58
testq %rbx, %rbx
je 0x9945
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9d3a
movq 0x9b3f(%rip), %r14      # 0x13468
xorl %ebx, %ebx
testq %r14, %r14
je 0x9907
movq 0x88(%r14), %rdi
callq 0x9a7c
movq 0x90(%r14), %r14
jmp 0x992b
movq 0x9b1c(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x9962
movq %rbx, %rdi
callq 0x9d3a
movq 0x90(%rbx), %rbx
jmp 0x994c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: systray_update
void
systray_update(void) {
   Systray *i;
   Monitor *m;
   int x = 1;

   int pos = sw;//blw;
   int pos_y;

   /* get primary */
   for(m = mons; m && !m->primary; m = m->next);
   pos = m->bw;

   if(topbar)
      pos_y = m->my;
   else
      pos_y = sh - m->bh;

   if(!systray_enable) return;

   if(!trayicons) {
      pos -= 1;
      XMoveResizeWindow(dpy, traywin, pos, 0, 1, 1);
      return;
   }

   for(i = trayicons; i; i = i->next) {
      XMapWindow(dpy, i->win);
      XMoveResizeWindow(dpy, i->win, (i->geo.x = x), 0, i->geo.width, i->geo.height);

      x += i->geo.width + systray_spacing;
   }

   pos -= x;
   XMoveResizeWindow(dpy, traywin, pos, pos_y, x, m->bh);

   XMapRaised(dpy, traywin);
   XSync(dpy, False);

   /* update status bar */
   drawbar(m);

   return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x9aef(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x9990
cmpl $0x0, 0xb8(%rbx)
jne 0x9990
movq 0x90(%rbx), %rbx
jmp 0x9979
movl 0x20(%rbx), %ebp
movq 0x9af6(%rip), %r12      # 0x13490
testq %r12, %r12
je 0x9a4f
movl 0x2c(%rbx), %r14d
movl $0x1, %r15d
movq 0x9ad4(%rip), %rdi      # 0x13488
movq (%r12), %rsi
callq 0x5420
movq 0x9ac4(%rip), %rdi      # 0x13488
movq (%r12), %rsi
movw %r15w, 0x8(%r12)
movswl %r15w, %edx
movzwl 0xc(%r12), %r8d
movzwl 0xe(%r12), %r9d
xorl %ecx, %ecx
callq 0x53a0
movzwl 0xc(%r12), %eax
addl %eax, %r15d
addl $0x2, %r15d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x99ad
subl %r15d, %ebp
movq 0x9a82(%rip), %rdi      # 0x13488
movq 0x9a8b(%rip), %rsi      # 0x13498
movl 0x24(%rbx), %r9d
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x53a0
movq 0x9a63(%rip), %rdi      # 0x13488
movq 0x9a6c(%rip), %rsi      # 0x13498
callq 0x5720
movq 0x9a50(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77ff
decl %ebp
movq 0x9a30(%rip), %rdi      # 0x13488
movq 0x9a39(%rip), %rsi      # 0x13498
movl %ebp, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x53a0
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: showhide
void
showhide(Client *c) {
   if(!c)
      return;

   if(ISVISIBLE(c))
   { /* show clients top down */
      XMoveWindow(dpy, c->win, c->x, c->y);
      if((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && !c->isfullscreen)
         resize(c, c->x, c->y, c->w, c->h, False);
      showhide(c->snext);
   }
   else { /* hide clients bottom up */
      showhide(c->snext);
      XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
   }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x9b22
cmpl $0x0, 0x180(%rbx)
jne 0x9aa8
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9b24
movq 0x99d9(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl 0x108(%rbx), %edx
movl 0x10c(%rbx), %ecx
callq 0x5080
movq 0x1a0(%rbx), %rax
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x9ae9
cmpl $0x0, 0x168(%rbx)
je 0x9b16
cmpl $0x0, 0x160(%rbx)
jne 0x9b16
movl 0x108(%rbx), %esi
movl 0x10c(%rbx), %edx
movl 0x110(%rbx), %ecx
movl 0x114(%rbx), %r8d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x7373
movq 0x198(%rbx), %rbx
jmp 0x9a80
popq %rbx
retq
movq 0x198(%rbx), %rdi
callq 0x9a7c
movq 0x9951(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl 0x9b28(%rip), %edx      # 0x1366c
addl %edx, %edx
addl 0x108(%rbx), %edx
movl 0x10c(%rbx), %ecx
popq %rbx
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: focus
void
focus(Client *c) {
   Monitor *m;

   if(menu) return;
   if(!c || !ISVISIBLE(c) || c->iszombie)
      for(c = selmon->stack; c && (!ISVISIBLE(c) || c->iszombie); c = c->snext);
   for(m = mons; m; m = m->next)
      if(m->sel && m->sel != c)
         unfocus(m->sel, False);

   if(c) {
      if(c->mon != selmon)
         focusmon(c->mon);
      if(c->isurgent)
         clearurgent(c);
      detachstack(c);
      attachstack(c);
      grabbuttons(c, True);
      XSetWindowBorder(dpy, c->win, dc.colors[1][ColBorder]);
      XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
      selmon->sel = c;
   }
   else
   {
      XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
      selmon->sel = NULL;
   }
   drawbars();
}

// Assembly:
cmpq $0x0, 0x9920(%rip)      # 0x13480
je 0x9b63
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9b98
cmpl $0x0, 0x180(%rbx)
jne 0x9b8f
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9b98
cmpl $0x0, 0x17c(%rbx)
je 0x9bde
movq 0x98d1(%rip), %rax      # 0x13470
movq 0x88(%rax), %rbx
testq %rbx, %rbx
je 0x9bdc
cmpl $0x0, 0x180(%rbx)
jne 0x9bca
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9bd3
cmpl $0x0, 0x17c(%rbx)
je 0x9bde
movq 0x198(%rbx), %rbx
jmp 0x9ba6
xorl %ebx, %ebx
movq 0x9883(%rip), %r15      # 0x13468
testq %r15, %r15
je 0x9c28
movq 0x80(%r15), %r14
testq %r14, %r14
je 0x9c1f
cmpq %rbx, %r14
je 0x9c1f
movq %r14, %rdi
xorl %esi, %esi
callq 0x9e79
movq 0x987c(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x98e6(%rip), %rdx      # 0x13500
callq 0x52e0
movq 0x90(%r15), %r15
jmp 0x9be5
testq %rbx, %rbx
je 0x9cea
movq 0x1a0(%rbx), %rdi
cmpq 0x9831(%rip), %rdi      # 0x13470
je 0x9c46
callq 0x9dcd
cmpl $0x0, 0x184(%rbx)
je 0x9c96
movl $0x0, 0x184(%rbx)
movq 0x9828(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5430
testq %rax, %rax
je 0x9c96
movq %rax, %r14
andb $-0x2, 0x1(%rax)
movq 0x9809(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq %rax, %rdx
callq 0x5790
movq %r14, %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x9df6
movq 0x1a0(%rbx), %rax
movq 0x88(%rax), %rcx
movq %rcx, 0x198(%rbx)
movq %rbx, 0x88(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9e79
movq 0x97ba(%rip), %rdi      # 0x13488
leaq 0x1a8(%rbx), %r14
movq 0x1a8(%rbx), %rsi
movq 0x9835(%rip), %rdx      # 0x13518
callq 0x52e0
jmp 0x9cf3
leaq 0x995f(%rip), %r14      # 0x13650
xorl %ebx, %ebx
movq 0x978e(%rip), %rdi      # 0x13488
movq (%r14), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x54a0
movq 0x9760(%rip), %rax      # 0x13470
movq %rbx, 0x80(%rax)
movq 0x974a(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x9d34
movq %rbx, %rdi
callq 0x77ff
movq 0x90(%rbx), %rbx
jmp 0x9d1e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: arrangemon
void
arrangemon(Monitor *m) {
   strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);
   if(m->lt[m->sellt]->arrange)
      m->lt[m->sellt]->arrange(m);
   restack(m);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x5c(%rdi), %eax
movq 0xa0(%rdi,%rax,8), %r14
movq 0x8(%r14), %rsi
movl $0x10, %edx
callq 0x5610
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x9d68
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa456
// File: /workspace/github_c_makefile_star2_O1/Cloudef[P]dwm-fork/dwm.c
// Function: unfocus
void
unfocus(Client *c, Bool setfocus) {
   if(!c)
      return;
   grabbuttons(c, False);
   XSetWindowBorder(dpy, c->win, dc.colors[0][ColBorder]);
   if(setfocus)
      XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
}

// Assembly:
testq %rdi, %rdi
je 0x9dcc
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
callq 0x9e79
movq 0x96f5(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x975f(%rip), %rdx      # 0x13500
callq 0x52e0
testl %ebx, %ebx
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
je 0x9dcc
movq 0x96cf(%rip), %rdi      # 0x13488
movq 0x9890(%rip), %rsi      # 0x13650
movl $0x1, %edx
xorl %ecx, %ecx
jmp 0x54a0
retq