LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x730b
movq %rax, %r14
xorl %ebp, %ebp
testq %rax, %rax
je 0x6f85
movq %r14, %rax
incl %ebp
movq 0x190(%rax), %rdi
callq 0x730b
testq %rax, %rax
jne 0x6f72
movl %ebp, %eax
shrl %eax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incl %r13d
cmpl %eax, %r13d
ja 0x6fa2
movl %r13d, %ecx
imull %r13d, %ecx
cmpl %ebp, %ecx
jb 0x6f8f
testl %r13d, %r13d
je 0x6fb6
leal -0x1(%r13), %r8d
movl %r8d, %eax
imull %r13d, %eax
cmpl %ebp, %eax
jae 0x6fb9
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 0x7095
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 0x703c
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 0x7058
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 0x7353
movq 0x190(%r14), %rdi
callq 0x730b
movq %rax, %r14
movl %r12d, %edi
testq %rax, %rax
jne 0x700f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x78(%rdi), %rdi
callq 0x730b
testq %rax, %rax
je 0x7241
movq %rax, %r14
xorl %ebp, %ebp
movq 0x190(%rax), %rdi
callq 0x730b
decl %ebp
testq %rax, %rax
jne 0x70ce
testl %ebp, %ebp
je 0x7241
movq 0x8(%rsp), %rax
movl 0x44(%rax), %r8d
cvtsi2ss %r8d, %xmm0
mulss 0x10(%rax), %xmm0
cvttss2si %xmm0, %ebx
movl 0x38(%rax), %esi
movl 0x3c(%rax), %edx
movl 0x40(%rax), %ecx
movl 0x150(%r14), %eax
addl %eax, %eax
subl %eax, %ecx
cmpl $-0x1, %ebp
cmovnel %ebx, %r8d
subl %eax, %r8d
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x7353
cmpl $-0x1, %ebp
je 0x7241
movl %ebp, %ecx
notl %ecx
movq 0x8(%rsp), %rsi
movl 0x3c(%rsi), %edi
leal (%rdi,%rbx), %edx
movl 0x114(%r14), %eax
addl 0x10c(%r14), %eax
movl %edx, 0x4(%rsp)
cmpl %eax, %edx
jle 0x7171
movl 0x150(%r14), %edx
leal (%rax,%rdx,2), %eax
addl 0x44(%rsi), %edi
movl %eax, 0x4(%rsp)
subl %eax, %edi
movq %rdi, 0x10(%rsp)
jmp 0x717b
movl 0x44(%rsi), %eax
subl %ebx, %eax
movq %rax, 0x10(%rsp)
movl 0x38(%rsi), %r12d
movl 0x40(%rsi), %r13d
movl %r13d, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r15d
cmpl 0x24(%rsi), %eax
cmovll %r13d, %r15d
movq 0x190(%r14), %rdi
callq 0x730b
testq %rax, %rax
je 0x7241
movq %rax, %r14
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
subl %ebp, %ebx
subl $0x1, %ebx
jae 0x71d3
movl 0x150(%r14), %eax
movq 0x8(%rsp), %rbp
addl 0x38(%rbp), %r13d
leal (%r12,%rax,2), %ecx
addl %eax, %eax
subl %ecx, %r13d
jmp 0x71e7
movl 0x150(%r14), %eax
addl %eax, %eax
movl %r15d, %r13d
subl %eax, %r13d
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %rcx
movl %ecx, %r8d
subl %eax, %r8d
movq %r14, %rdi
movl %r12d, %esi
movl 0x4(%rsp), %edx
movl %r13d, %ecx
xorl %r9d, %r9d
callq 0x7353
movl 0x40(%rbp), %r13d
cmpl %r13d, %r15d
je 0x7229
movl 0x110(%r14), %eax
movl 0x150(%r14), %ecx
addl 0x108(%r14), %eax
leal (%rax,%rcx,2), %r12d
movq 0x190(%r14), %rdi
callq 0x730b
movq %rax, %r14
testq %rax, %rax
jne 0x71b3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rdi
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x72ba
movq %rdi, %rax
cmpl $0x0, 0x180(%rax)
jne 0x7284
movq 0x1a0(%rax), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rax)
je 0x728e
cmpl $0x1, 0x170(%rax)
adcl $0x0, %ecx
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x7265
testl %ecx, %ecx
je 0x72bc
leaq 0x6087(%rip), %rdx      # 0xd32c
movl $0x10, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50a0
movq 0x78(%rbx), %rdi
jmp 0x72bc
xorl %edi, %edi
callq 0x730b
testq %rax, %rax
je 0x7303
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 0x7353
movq 0x190(%r14), %rdi
callq 0x730b
movq %rax, %r14
testq %rax, %rax
jne 0x72c9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75f7
cmpl $0x0, 0x160(%rbx)
jne 0x75f7
movq 0x110(%rbx), %rax
movq %rax, 0x128(%rbx)
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movl %ecx, 0x8(%rax)
movups 0x108(%rbx), %xmm0
movl %esi, 0x108(%rbx)
movl %edx, 0x10c(%rbx)
movl %ecx, 0x110(%rbx)
movups %xmm0, 0x118(%rbx)
movl %r8d, 0xc(%rax)
movl %r8d, 0x114(%rbx)
movl 0x150(%rbx), %ecx
movl %ecx, 0x10(%rax)
movq 0xbe49(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl $0x1f, %edx
movq %rax, %rcx
callq 0x50d0
movq %rbx, %rdi
callq 0x766f
movq 0xbe26(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbe04(%rip), %rax      # 0x13488
movq %rax, 0x18(%r8)
movq 0x1a8(%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movups 0x108(%rdi), %xmm0
movups %xmm0, 0x30(%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_O3/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 0xbd90(%rip), %rax      # 0x13468
testq %rax, %rax
je 0x7702
movl 0x38(%rax), %ecx
cmpl %edi, %ecx
jg 0x76f9
addl 0x40(%rax), %ecx
cmpl %edi, %ecx
jle 0x76f9
movl 0x3c(%rax), %ecx
cmpl %esi, %ecx
jg 0x76f9
addl 0x44(%rax), %ecx
cmpl %esi, %ecx
jg 0x7709
movq 0x90(%rax), %rax
jmp 0x76d8
movq 0xbd67(%rip), %rax      # 0x13470
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x77cb
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rsi
movb $0x0, (%rdx)
movq 0xbd4a(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x52f0
cmpq $0x0, 0x18(%r15)
je 0x77cb
cmpq $0x1f, 0x20(%rsp)
jne 0x776d
movq 0x18(%rsp), %rsi
leal -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x5600
jmp 0x77b4
movq 0xbd14(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x5240
testl %eax, %eax
js 0x77b4
cmpl $0x0, 0xc(%rsp)
jle 0x77b4
movq 0x10(%rsp), %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x77b4
leal -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x5600
movq %r15, %rdi
callq 0x5570
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_O3/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 0x829b
movl $0x1, %r8d
movl %eax, %edx
cmpb $0xc, %r9b
ja 0x8279
decl %edx
jmp 0x8282
movl %ecx, %r10d
movb %r9b, (%rsi,%r10)
incl %ecx
movb (%rdi,%r8), %r9b
testb %r9b, %r9b
je 0x8297
leaq 0x1(%r8), %r10
cmpl %eax, %r8d
movq %r10, %r8
jb 0x826f
movl %ecx, %ecx
jmp 0x829d
movl %eax, %edx
movb $0x0, (%rsi,%rcx)
movq 0xb398(%rip), %rdi      # 0x13640
testq %rdi, %rdi
je 0x82c1
leaq -0x10(%rbp), %rbx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x55e0
movzwl 0x4(%rbx), %eax
jmp 0x82cd
movq 0xb380(%rip), %rdi      # 0x13648
callq 0x54b0
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaf85(%rip), %rbx      # 0x13490
testq %rbx, %rbx
je 0x855e
movq 0xaf71(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5350
movq 0xaf62(%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 0x56e0
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rbx
testq %r14, %r14
jne 0x8510
movq 0xaf23(%rip), %rdi      # 0x13488
movq 0xaf74(%rip), %rsi      # 0x134e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54d0
movq 0xaf0c(%rip), %rdi      # 0x13488
movq 0xaf15(%rip), %rsi      # 0x13498
callq 0x5300
movq 0xaef9(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
// File: /workspace/github_c_makefile_star2_O3/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 0xaec0(%rip), %rdi      # 0x13488
movq %rdx, %rsi
xorl %edx, %edx
callq 0x55d0
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 0xae87(%rip), %rdi      # 0x13488
movl $0x20000, %ecx          # imm = 0x20000
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %r8
callq 0x54f0
movq 0xae6e(%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_O3/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, 0xb1d7(%rip)      # 0x13818
movq 0xae40(%rip), %rdi      # 0x13488
callq 0x55c0
movq %rax, %rbx
movl (%rax), %edx
xorl %ebp, %ebp
movl $0x0, %eax
testl %edx, %edx
je 0x86a2
movl $0x1, %r14d
movl %ebp, %ecx
shll %cl, %r14d
xorl %r15d, %r15d
movl %edx, %eax
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r15d, %eax
movb (%rcx,%rax), %r12b
movq 0xae06(%rip), %rdi      # 0x13488
movl $0xff7f, %esi           # imm = 0xFF7F
callq 0x5620
cmpb %al, %r12b
jne 0x8698
movl %r14d, 0xb180(%rip)     # 0x13818
incl %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jb 0x866d
incl %ebp
movl %eax, %edx
cmpl $0x8, %ebp
jne 0x8654
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x51c0
// File: /workspace/github_c_makefile_star2_O3/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 0xab54(%rip), %rdi      # 0x13470
testq %rdi, %rdi
je 0x895b
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x895c
cmpl $0x0, 0x180(%rcx)
jne 0x8949
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x8952
cmpl $0x0, 0x160(%rcx)
jne 0x895b
movq 0x190(%rcx), %rcx
jmp 0x8925
retq
testq %rax, %rax
je 0x8972
movl (%rax), %ecx
cmpl $-0x1, %ecx
je 0x8972
movl %ecx, 0x6c(%rdi)
movl (%rax), %esi
jmp 0x97e0
movl 0x68(%rdi), %eax
movl %eax, 0x6c(%rdi)
xorl %esi, %esi
testl %eax, %eax
sete %sil
jmp 0x97e0
// File: /workspace/github_c_makefile_star2_O3/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 0xaae3(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x8ac7
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x8ac7
cmpl $0x0, (%rdi)
jle 0x8a32
movq 0x190(%rcx), %rdi
testq %rdi, %rdi
je 0x89f0
cmpl $0x0, 0x180(%rdi)
jne 0x89da
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0x89e7
cmpl $0x0, 0x170(%rdi)
je 0x8ab5
movq 0x190(%rdi), %rdi
jmp 0x89b6
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0x8ac7
cmpl $0x0, 0x180(%rdi)
jne 0x8a1c
movq 0x1a0(%rdi), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rdi)
je 0x8a29
cmpl $0x0, 0x170(%rdi)
je 0x8ab5
movq 0x190(%rdi), %rdi
jmp 0x89f4
movq 0x78(%rax), %rax
cmpq %rcx, %rax
je 0x8a78
xorl %edi, %edi
cmpl $0x0, 0x180(%rax)
jne 0x8a5c
movq 0x1a0(%rax), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rax)
je 0x8a67
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
movq 0x190(%rax), %rax
cmpq %rcx, %rax
jne 0x8a3d
testq %rdi, %rdi
jne 0x8ab5
xorl %edi, %edi
cmpl $0x0, 0x180(%rax)
jne 0x8a99
movq 0x1a0(%rax), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rax)
je 0x8aa4
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x8a7a
testq %rdi, %rdi
je 0x8ac7
callq 0x9b07
movq 0xa9af(%rip), %rdi      # 0x13470
popq %rax
jmp 0xa3f3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8b37
movq %rdi, %rax
movq 0xa998(%rip), %rdi      # 0x13470
movl 0x5c(%rdi), %ecx
movq 0xa0(%rdi,%rcx,8), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x8b37
movss (%rax), %xmm0
movss 0x453e(%rip), %xmm1     # 0xd034
ucomiss %xmm0, %xmm1
jbe 0x8b02
movss 0x10(%rdi), %xmm1
jmp 0x8b0a
movss 0x4526(%rip), %xmm1     # 0xd030
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x44f3(%rip), %xmm2     # 0xd010
ucomisd %xmm1, %xmm2
ja 0x8b37
ucomisd 0x44ed(%rip), %xmm1     # 0xd018
ja 0x8b37
movss %xmm0, 0x10(%rdi)
jmp 0x98a3
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa930(%rip), %rax      # 0x13470
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x8bd5
cmpl $0x0, 0x168(%rbx)
je 0x8b6c
cmpl $0x0, 0x164(%rbx)
jne 0x8bd5
movl $0x0, 0x168(%rbx)
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0x8bd5
movq 0x1a0(%rbx), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x8ba0
leaq 0x190(%rdx), %rcx
cmpq %rbx, %rdx
jne 0x8b89
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 0x9b07
movq 0x1a0(%rbx), %rdi
popq %rbx
jmp 0x98a3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa8a0(%rip), %rdi      # 0x13488
leaq 0x4550(%rip), %rsi      # 0xd13f
xorl %edx, %edx
callq 0x55d0
movq %rax, 0xa8a3(%rip)      # 0x134a0
movq 0xa884(%rip), %rdi      # 0x13488
leaq 0x4541(%rip), %rsi      # 0xd14c
xorl %edx, %edx
callq 0x55d0
movq %rax, 0xa88f(%rip)      # 0x134a8
movq 0xa850(%rip), %rax      # 0x13470
movq 0x80(%rax), %r14
testq %r14, %r14
je 0x8d9c
movq 0xa851(%rip), %rdi      # 0x13488
leaq 0x450e(%rip), %rsi      # 0xd14c
xorl %edx, %edx
callq 0x55d0
movq %rax, 0xa85c(%rip)      # 0x134a8
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq 0xa829(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
leaq 0x4(%rsp), %rcx
movq %rbx, %rdx
callq 0x56b0
testl %eax, %eax
setne %al
movq (%rbx), %rdi
testq %rdi, %rdi
setne %cl
testb %cl, %al
je 0x8d2f
movl 0x4(%rsp), %ecx
testl %ecx, %ecx
je 0x8d22
decl %ecx
movq 0xa80a(%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 0x8ca3
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
callq 0x5070
testl %ebx, %ebx
je 0x8d2f
leaq 0x8(%rsp), %r8
movl $0x21, (%r8)
movq 0xa798(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
movq %rsi, 0x20(%r8)
movq 0xa7af(%rip), %rax      # 0x134a0
movq %rax, 0x28(%r8)
movl $0x20, 0x30(%r8)
movq 0xa7a4(%rip), %rax      # 0x134a8
movq %rax, 0x38(%r8)
movq $0x0, 0x40(%r8)
movq 0xa771(%rip), %rdi      # 0x13488
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54f0
jmp 0x8d9c
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
callq 0x5070
movq 0xa752(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0x313d(%rip), %rdi      # 0xbe7f
callq 0x5670
movq 0xa73a(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x5160
movq 0xa72c(%rip), %rdi      # 0x13488
movq 0xa70d(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
callq 0x5790
movq 0xa70b(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x28dc(%rip), %rdi     # 0x64af
callq 0x5670
movq 0xa6f1(%rip), %rdi      # 0x13488
callq 0x5390
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa352(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x9133
cmpl $0x0, 0x17c(%rax)
je 0x9134
retq
xorl %ecx, %ecx
cmpl $0x0, 0x180(%rax)
sete %cl
movl %ecx, 0x180(%rax)
je 0x9133
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_O3/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 0xa300(%rip), %rdi      # 0x13470
movl 0x58(%rdi), %edx
cmpl 0x60(%rdi,%rdx,4), %esi
jne 0x917a
retq
xorq $0x1, %rdx
movl %edx, 0x58(%rdi)
andl (%rax), %ecx
je 0x98a3
movl %ecx, 0x60(%rdi,%rdx,4)
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/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 0xa2a3(%rip), %rcx      # 0x13468
cmpq $0x0, 0x90(%rcx)
je 0x9238
cmpl $0x0, (%rdi)
movq 0xa297(%rip), %rax      # 0x13470
jle 0x91ee
movq 0x90(%rax), %rdx
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq %rcx, %rbx
jmp 0x9213
cmpq %rcx, %rax
je 0x9204
movq %rcx, %rbx
movq 0x90(%rcx), %rcx
cmpq %rax, %rcx
jne 0x91f3
jmp 0x9213
movq %rcx, %rbx
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0x9204
cmpq %rax, %rbx
je 0x9238
movq 0x80(%rax), %rdi
movl $0x1, %esi
callq 0x9d26
movq %rbx, 0xa240(%rip)      # 0x13470
xorl %edi, %edi
popq %rbx
jmp 0x9b07
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa1be(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rsi
leaq 0x7dfc(%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 0x9308
addq %rax, %rsi
cmpq $0x0, 0x20(%rsi)
je 0x9308
addq $0x18, %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
jmp 0x9310
leaq 0x8(%rsp), %rdi
movq %r8, (%rdi)
callq 0xc7d0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa14b(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rsi
leaq 0x7d89(%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 0x9378
subq %rcx, %rax
addq %rax, %rsi
cmpq $0x0, -0x10(%rsi)
je 0x9378
addq $-0x18, %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
jmp 0x9387
leaq 0x7db9(%rip), %rax      # 0x11138
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xc7d0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa0d7(%rip), %rax      # 0x13470
movq 0x78(%rax), %rbx
testq %rbx, %rbx
je 0x93dd
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
sete %dl
leaq -0x216e(%rip), %rsi     # 0x7250
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x93dd
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x93df
cmpl $0x0, 0x168(%rax)
je 0x93df
popq %rbx
retq
movq 0x1a0(%rbx), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x9401
leaq 0x190(%rdx), %rcx
cmpq %rbx, %rdx
jne 0x93ea
movq 0x190(%rbx), %rdi
movq %rdi, (%rax)
testq %rdi, %rdi
je 0x9415
callq 0x9b07
movq 0x1a0(%rbx), %rdi
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x9448
movq %rax, %rcx
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x9425
movq %rbx, 0x190(%rcx)
movq $0x0, 0x190(%rbx)
jmp 0x9457
movq $0x0, 0x190(%rbx)
movq %rbx, 0x78(%rdi)
popq %rbx
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/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 0xa00c(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x948f
pushq %rax
cmpl $0x0, 0x168(%rax)
je 0x9490
leaq 0x168(%rax), %rcx
xorl %edx, %edx
cmpl $0x0, 0x164(%rax)
setne %dl
jmp 0x94a7
retq
cmpl $0x0, 0x164(%rax)
je 0x94af
addq $0x168, %rax            # imm = 0x168
movl $0x1, %edx
movq %rax, %rcx
movl %edx, (%rcx)
popq %rax
jmp 0x98a3
movl 0x108(%rax), %esi
movl 0x10c(%rax), %edx
movl 0x128(%rax), %ecx
movl 0x12c(%rax), %r8d
movq %rax, %rdi
callq 0x75cf
movq 0x9f99(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rax
leaq 0x168(%rax), %rcx
cmpl $0x0, 0x168(%rax)
jne 0x9481
movl $0x1, %edx
jmp 0x94a7
// File: /workspace/github_c_makefile_star2_O3/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 0x9f73(%rip), %rbx      # 0x13470
testq %rdi, %rdi
je 0x956f
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x956f
movl 0x5c(%rbx), %ecx
xorl %eax, %eax
cmpq 0xa0(%rbx,%rcx,8), %rdx
setne %al
xorl %ecx, %eax
movq 0xb0(%rbx), %rdx
testq %rdx, %rdx
je 0x9549
movl %eax, 0x5c(%rbx)
movl %eax, %eax
movq %rdx, 0xa0(%rbx,%rax,8)
movq 0x9f34(%rip), %rbx      # 0x13470
movq $0x0, 0xb0(%rbx)
jmp 0x956f
movq 0xa0(%rbx,%rcx,8), %rcx
movq %rcx, 0xb0(%rbx)
movl %eax, 0x5c(%rbx)
movq (%rdi), %rcx
movl %eax, %eax
movq %rcx, 0xa0(%rbx,%rax,8)
movq 0x9f01(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x5600
cmpq $0x0, 0x80(%rbx)
je 0x959e
movq %rbx, %rdi
popq %rbx
jmp 0x98a3
movq %rbx, %rdi
popq %rbx
jmp 0x77d8
// File: /workspace/github_c_makefile_star2_O3/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 0x9ebe(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x9669
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x9669
cmpl $0x0, 0x160(%rbx)
movq 0x9eaf(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq 0x9ee9(%rip), %rdx      # 0x134d0
je 0x9671
xorl %r14d, %r14d
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq $0x0
callq 0x5650
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 0x75cf
jmp 0x9700
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %r14d
leaq 0x9e5a(%rip), %rax      # 0x134d8
movl $0x4, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %rax
callq 0x5650
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 0x75cf
cmpl $0x0, 0x174(%rbx)
jne 0x9700
movq 0x9d94(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x1a0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: togglemenu
void
togglemenu(const Arg *arg) {
   if(!menu)
      openmenu(&rootMenu[0]);
   else
      closemenus();
}

// Assembly:
cmpq $0x0, 0x9d65(%rip)      # 0x13480
jne 0xbcd9
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x9d59(%rip), %rdi      # 0x13488
movq 0x9f1a(%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 0x5610
addq $0x20, %rsp
movl (%rbx), %esi
movl (%r14), %edx
leaq 0x7e2a(%rip), %rdi      # 0x115a0
callq 0xb94f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9ce3(%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 0x97a0
retq
xorl %edx, %esi
movl %esi, 0x60(%rdi,%rcx,4)
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/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 0x9cbb(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x97d2
movl 0x15c(%rcx), %edx
movl $0x1ff, %esi            # imm = 0x1FF
andl (%rax), %esi
cmpl %esi, %edx
jne 0x97d3
retq
xorl %edx, %esi
movl %esi, 0x15c(%rcx)
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/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 0x98a2
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $-0x1, %esi
je 0x9802
cmpl %esi, %eax
jne 0x980a
jmp 0x989d
xorl %esi, %esi
testl %eax, %eax
sete %sil
movl %esi, 0x68(%rbx)
movq %rbx, %rdi
callq 0x6b10
movq 0x9c6c(%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 0x98a3
cmpl $0x0, 0xb8(%rbx)
je 0x989d
cmpl $0x0, 0x68(%rbx)
je 0x9878
leaq 0x8(%rsp), %rcx
movl $0x0, 0x4(%rcx)
movq 0x9c28(%rip), %rdi      # 0x13488
movq 0x9c31(%rip), %rsi      # 0x13498
movl $0x2, %edx
callq 0x50d0
callq 0x990f
jmp 0x989d
xorl %eax, %eax
subl 0x24(%rbx), %eax
leaq 0x8(%rsp), %rcx
movl %eax, 0x4(%rcx)
movq 0x9bfc(%rip), %rdi      # 0x13488
movq 0x9c05(%rip), %rsi      # 0x13498
movl $0x2, %edx
callq 0x50d0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x98c8
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
callq 0x9a23
xorl %edi, %edi
callq 0x9b07
movq %rbx, %rdi
popq %rbx
jmp 0x9ce9
movq 0x9b99(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x98e9
movq 0x88(%rbx), %rdi
callq 0x9a23
movq 0x90(%rbx), %rbx
jmp 0x98cf
xorl %edi, %edi
callq 0x9b07
movq 0x9b71(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x990d
movq %rbx, %rdi
callq 0x9ce9
movq 0x90(%rbx), %rbx
jmp 0x98f7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9b4a(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x9935
cmpl $0x0, 0xb8(%rbx)
jne 0x9937
movq 0x90(%rbx), %rbx
jmp 0x991e
xorl %ebx, %ebx
movl 0x20(%rbx), %ebp
movq 0x9b4f(%rip), %r12      # 0x13490
testq %r12, %r12
je 0x99f6
movl 0x2c(%rbx), %r14d
movl $0x1, %r15d
movq 0x9b2d(%rip), %rdi      # 0x13488
movq (%r12), %rsi
callq 0x5420
movq 0x9b1d(%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 0x9954
subl %r15d, %ebp
movq 0x9adb(%rip), %rdi      # 0x13488
movq 0x9ae4(%rip), %rsi      # 0x13498
movl 0x24(%rbx), %r9d
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x53a0
movq 0x9abc(%rip), %rdi      # 0x13488
movq 0x9ac5(%rip), %rsi      # 0x13498
callq 0x5710
movq 0x9aa9(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77d8
decl %ebp
movq 0x9a89(%rip), %rdi      # 0x13488
movq 0x9a92(%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_O3/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
testq %rdi, %rdi
je 0x9ad1
movq %rdi, %rbx
cmpl $0x0, 0x180(%rbx)
jne 0x9a53
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9ad3
movq 0x9a2e(%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 0x9a94
cmpl $0x0, 0x168(%rbx)
je 0x9ac1
cmpl $0x0, 0x160(%rbx)
jne 0x9ac1
movl 0x108(%rbx), %esi
movl 0x10c(%rbx), %edx
movl 0x110(%rbx), %ecx
movl 0x114(%rbx), %r8d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x7353
movq 0x198(%rbx), %rbx
testq %rbx, %rbx
jne 0x9a30
popq %rbx
retq
movq 0x198(%rbx), %rdi
callq 0x9a23
movq 0x99a2(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl 0x9b79(%rip), %edx      # 0x1366c
addl %edx, %edx
addl 0x108(%rbx), %edx
movl 0x10c(%rbx), %ecx
popq %rbx
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O3/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, 0x9971(%rip)      # 0x13480
je 0x9b12
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9b47
cmpl $0x0, 0x180(%rbx)
jne 0x9b3e
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9b47
cmpl $0x0, 0x17c(%rbx)
je 0x9b8d
movq 0x9922(%rip), %rax      # 0x13470
movq 0x88(%rax), %rbx
testq %rbx, %rbx
je 0x9b8b
cmpl $0x0, 0x180(%rbx)
jne 0x9b79
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9b82
cmpl $0x0, 0x17c(%rbx)
je 0x9b8d
movq 0x198(%rbx), %rbx
jmp 0x9b55
xorl %ebx, %ebx
movq 0x98d4(%rip), %r15      # 0x13468
testq %r15, %r15
je 0x9bd7
movq 0x80(%r15), %r14
testq %r14, %r14
je 0x9bce
cmpq %rbx, %r14
je 0x9bce
movq %r14, %rdi
xorl %esi, %esi
callq 0x9e2a
movq 0x98cd(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x9937(%rip), %rdx      # 0x13500
callq 0x52e0
movq 0x90(%r15), %r15
jmp 0x9b94
testq %rbx, %rbx
je 0x9c99
movq 0x1a0(%rbx), %rdi
cmpq 0x9882(%rip), %rdi      # 0x13470
je 0x9bf5
callq 0x9d7c
cmpl $0x0, 0x184(%rbx)
je 0x9c45
movl $0x0, 0x184(%rbx)
movq 0x9879(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5430
testq %rax, %rax
je 0x9c45
movq %rax, %r14
andb $-0x2, 0x1(%rax)
movq 0x985a(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq %rax, %rdx
callq 0x5780
movq %r14, %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x9da5
movq 0x1a0(%rbx), %rax
movq 0x88(%rax), %rcx
movq %rcx, 0x198(%rbx)
movq %rbx, 0x88(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9e2a
movq 0x980b(%rip), %rdi      # 0x13488
leaq 0x1a8(%rbx), %r14
movq 0x1a8(%rbx), %rsi
movq 0x9886(%rip), %rdx      # 0x13518
callq 0x52e0
jmp 0x9ca2
leaq 0x99b0(%rip), %r14      # 0x13650
xorl %ebx, %ebx
movq 0x97df(%rip), %rdi      # 0x13488
movq (%r14), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x54a0
movq 0x97b1(%rip), %rax      # 0x13470
movq %rbx, 0x80(%rax)
movq 0x979b(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0x9ce3
movq %rbx, %rdi
callq 0x77d8
movq 0x90(%rbx), %rbx
jmp 0x9ccd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5600
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x9d17
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa3f3
// File: /workspace/github_c_makefile_star2_O3/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 0x9d7b
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
callq 0x9e2a
movq 0x9746(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x97b0(%rip), %rdx      # 0x13500
callq 0x52e0
testl %ebx, %ebx
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
je 0x9d7b
movq 0x9720(%rip), %rdi      # 0x13488
movq 0x98e1(%rip), %rsi      # 0x13650
movl $0x1, %edx
xorl %ecx, %ecx
jmp 0x54a0
retq