LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0xbf1d(%rip), %rax      # 0x13468
movq (%rax), %rax
testq %rax, %rax
je 0x7577
movl 0x38(%rax), %ecx
cmpl %edi, %ecx
jg 0x756f
addl 0x40(%rax), %ecx
cmpl %edi, %ecx
jle 0x756f
movl 0x3c(%rax), %ecx
cmpl %esi, %ecx
jg 0x756f
addl 0x44(%rax), %ecx
cmpl %esi, %ecx
jg 0x757e
addq $0x90, %rax
jmp 0x754b
movq 0xbef2(%rip), %rax      # 0x13470
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: wintoclient
Client *
wintoclient(Window w) {
   Client *c;
   Monitor *m;

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

// Assembly:
leaq 0xbee2(%rip), %rcx      # 0x13468
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x75b4
leaq 0x78(%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x75ab
cmpq %rdi, 0x1a8(%rax)
je 0x75b6
addq $0x190, %rax            # imm = 0x190
jmp 0x7592
addq $0x90, %rcx
jmp 0x7586
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x7673
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdi, %rsi
movb $0x0, (%rdx)
movq 0xbea0(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x52f0
cmpq $0x0, 0x18(%r15)
je 0x7673
cmpq $0x1f, 0x20(%rsp)
jne 0x7617
movq 0x18(%rsp), %rsi
leal -0x1(%r14), %edx
movq %rbx, %rdi
callq 0x5600
jmp 0x765e
movq 0xbe6a(%rip), %rdi      # 0x13488
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x5240
testl %eax, %eax
js 0x765e
cmpl $0x0, 0xc(%rsp)
jle 0x765e
movq 0x10(%rsp), %r15
movq (%r15), %rsi
testq %rsi, %rsi
je 0x765e
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
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %eax, %edx
movb (%rdi,%rcx), %r10b
movl %r8d, %r9d
testb %r10b, %r10b
je 0x8082
cmpl %eax, %ecx
jae 0x8082
cmpb $0xc, %r10b
ja 0x8076
decl %edx
jmp 0x807d
movb %r10b, (%rsi,%r9)
incl %r8d
incq %rcx
jmp 0x805c
movb $0x0, (%rsi,%r9)
movq 0xb5b2(%rip), %rdi      # 0x13640
testq %rdi, %rdi
je 0x80a7
leaq -0x10(%rbp), %rbx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x55e0
movzwl 0x4(%rbx), %eax
jmp 0x80b3
movq 0xb59a(%rip), %rdi      # 0x13648
callq 0x54b0
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: systray_get_width
int
systray_get_width(void) {
   int w = 0;
   Systray *i;

   if(!systray_enable) return 0;

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

   return w;
}

// Assembly:
leaq 0xb1f1(%rip), %rcx      # 0x13490
xorl %eax, %eax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x82b8
movzwl 0xc(%rcx), %edx
addl %edx, %eax
addl $0x2, %eax
addq $0x10, %rcx
jmp 0x82a1
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb1cc(%rip), %rbx      # 0x13490
movq 0xb1bd(%rip), %rdi      # 0x13488
testq %rbx, %rbx
je 0x8314
movq (%rbx), %rsi
callq 0x5350
movq 0xb1a9(%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
jmp 0x82c4
movq 0xb1c5(%rip), %rsi      # 0x134e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54d0
movq 0xb15d(%rip), %rdi      # 0x13488
movq 0xb166(%rip), %rsi      # 0x13498
callq 0x5300
movq 0xb14a(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
// File: /workspace/github_c_makefile_star2_O2/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 0xb111(%rip), %rdi      # 0x13488
movq %rdx, %rsi
xorl %edx, %edx
callq 0x55d0
movq %rax, 0x28(%r13)
movq %r15, 0x20(%r13)
movl $0x20, 0x30(%r13)
andq $0x0, 0x38(%r13)
movq %r14, 0x40(%r13)
movq %rbx, 0x48(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r13)
movq 0xb0db(%rip), %rdi      # 0x13488
movl $0x20000, %ecx          # imm = 0x20000
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %r8
callq 0x54f0
movq 0xb0c2(%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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0xb42b(%rip)      # 0x13818
movq 0xb094(%rip), %rdi      # 0x13488
callq 0x55c0
movq %rax, %rbx
xorl %ebp, %ebp
pushq $0x1
popq %r14
cmpl $0x8, %ebp
je 0x844d
movl %r14d, %r15d
movl %ebp, %ecx
shll %cl, %r15d
xorl %r12d, %r12d
movl (%rbx), %eax
cmpl %eax, %r12d
jae 0x8449
movq 0x8(%rbx), %rcx
imull %ebp, %eax
addl %r12d, %eax
movb (%rcx,%rax), %r13b
movq 0xb05a(%rip), %rdi      # 0x13488
movl $0xff7f, %esi           # imm = 0xFF7F
callq 0x5620
cmpb %al, %r13b
jne 0x8444
movl %r15d, 0xb3d4(%rip)     # 0x13818
incl %r12d
jmp 0x8412
incl %ebp
jmp 0x8402
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51c0
// File: /workspace/github_c_makefile_star2_O2/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 0xad5d(%rip), %rdi      # 0x13470
testq %rdi, %rdi
je 0x8755
leaq 0x78(%rdi), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x8756
cmpl $0x0, 0x180(%rcx)
jne 0x8743
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x874c
cmpl $0x0, 0x160(%rcx)
jne 0x8755
addq $0x190, %rcx            # imm = 0x190
jmp 0x871c
retq
testq %rax, %rax
je 0x876c
movl (%rax), %ecx
cmpl $-0x1, %ecx
je 0x876c
movl %ecx, 0x6c(%rdi)
movl (%rax), %esi
jmp 0x94d2
movl 0x68(%rdi), %eax
movl %eax, 0x6c(%rdi)
xorl %esi, %esi
testl %eax, %eax
sete %sil
jmp 0x94d2
// File: /workspace/github_c_makefile_star2_O2/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 0xace9(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x88b9
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x88b9
cmpl $0x0, (%rdi)
jle 0x87e5
movq %rcx, %rdi
movq 0x190(%rdi), %rdi
testq %rdi, %rdi
je 0x8879
cmpl $0x0, 0x180(%rdi)
jne 0x87d7
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0x87a8
cmpl $0x0, 0x170(%rdi)
jne 0x87a8
jmp 0x8867
addq $0x78, %rax
xorl %edi, %edi
movq (%rax), %rax
cmpq %rcx, %rax
je 0x8825
cmpl $0x0, 0x180(%rax)
jne 0x8812
movq 0x1a0(%rax), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rax)
je 0x881d
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
addq $0x190, %rax            # imm = 0x190
jmp 0x87eb
testq %rdi, %rdi
jne 0x8867
xorl %edi, %edi
cmpl $0x0, 0x180(%rax)
jne 0x884b
movq 0x1a0(%rax), %rcx
movl 0x58(%rcx), %edx
movl 0x60(%rcx,%rdx,4), %ecx
testl %ecx, 0x15c(%rax)
je 0x8856
cmpl $0x0, 0x170(%rax)
cmoveq %rax, %rdi
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x882c
testq %rdi, %rdi
je 0x88b9
callq 0x97fb
movq 0xabfd(%rip), %rdi      # 0x13470
popq %rax
jmp 0xa075
addq $0x78, %rax
movq %rax, %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x88b9
cmpl $0x0, 0x180(%rdi)
jne 0x88a7
movq 0x1a0(%rdi), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rdi)
je 0x88b0
cmpl $0x0, 0x170(%rdi)
je 0x8867
addq $0x190, %rdi            # imm = 0x190
jmp 0x8880
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8926
movq %rdi, %rax
movq 0xaba6(%rip), %rdi      # 0x13470
movl 0x5c(%rdi), %ecx
movq 0xa0(%rdi,%rcx,8), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x8926
movss (%rax), %xmm0
movss 0x475c(%rip), %xmm1     # 0xd044
ucomiss %xmm0, %xmm1
jbe 0x88f4
movss 0x10(%rdi), %xmm1
jmp 0x88fc
movss 0x4744(%rip), %xmm1     # 0xd040
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4704(%rip), %xmm2     # 0xd010
ucomisd %xmm1, %xmm2
ja 0x8926
ucomisd 0x46fe(%rip), %xmm1     # 0xd018
ja 0x8926
movss %xmm0, 0x10(%rdi)
jmp 0x958e
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab41(%rip), %rax      # 0x13470
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x896f
cmpl $0x0, 0x168(%rbx)
je 0x8956
movb $0x1, %cl
cmpl $0x0, 0x164(%rbx)
jne 0x8958
andl $0x0, 0x168(%rbx)
xorl %ecx, %ecx
movl 0x5c(%rax), %edx
movq 0xa0(%rax,%rdx,8), %rax
cmpq $0x0, 0x10(%rax)
sete %al
orb %cl, %al
je 0x8971
popq %rbx
retq
movq %rbx, %rdi
callq 0xb864
movq 0x1a0(%rbx), %rax
movq 0x78(%rax), %rcx
movq %rcx, 0x190(%rbx)
movq %rbx, 0x78(%rax)
movq %rbx, %rdi
callq 0x97fb
movq 0x1a0(%rbx), %rdi
popq %rbx
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: killclient
void
killclient(const Arg *arg) {
   XEvent ev;
   wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
   wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq 0xaad2(%rip), %rdi      # 0x13488
leaq 0x4792(%rip), %rsi      # 0xd14f
xorl %edx, %edx
callq 0x55d0
movq %rax, 0xaad5(%rip)      # 0x134a0
movq 0xaab6(%rip), %rdi      # 0x13488
leaq 0x4783(%rip), %rsi      # 0xd15c
xorl %edx, %edx
callq 0x55d0
movq %rax, 0xaac1(%rip)      # 0x134a8
movq 0xaa82(%rip), %rax      # 0x13470
movq 0x80(%rax), %r14
testq %r14, %r14
je 0x8b4a
movq 0xaa83(%rip), %rdi      # 0x13488
leaq 0x4750(%rip), %rsi      # 0xd15c
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x55d0
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movq %rax, 0xaa83(%rip)      # 0x134a8
movq 0xaa5c(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
leaq 0xc(%rsp), %rcx
movq %rbx, %rdx
callq 0x56b0
testl %eax, %eax
setne %al
movq (%rbx), %rdi
testq %rdi, %rdi
setne %cl
testb %cl, %al
je 0x8add
movslq 0xc(%rsp), %rax
movq 0xaa46(%rip), %rcx      # 0x134a8
subq $0x1, %rax
jb 0x8a75
xorl %edx, %edx
cmpq %rcx, (%rdi,%rax,8)
sete %dl
addl %edx, %ebp
jmp 0x8a62
orl $-0x1, 0xc(%rsp)
callq 0x5070
testl %ebp, %ebp
je 0x8add
leaq 0x10(%rsp), %r8
movl $0x21, (%r8)
movq 0xa9da(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
movq %rsi, 0x20(%r8)
movq 0xa9f1(%rip), %rax      # 0x134a0
movq %rax, 0x28(%r8)
movl $0x20, 0x30(%r8)
movq 0xa9e6(%rip), %rax      # 0x134a8
movq %rax, 0x38(%r8)
andq $0x0, 0x40(%r8)
movq 0xa9b6(%rip), %rdi      # 0x13488
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54f0
jmp 0x8b4a
movq 0xa9a4(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0x2da1(%rip), %rdi      # 0xb891
callq 0x5670
movq 0xa98c(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x5160
movq 0xa97e(%rip), %rdi      # 0x13488
movq 0xa95f(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
callq 0x5790
movq 0xa95d(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x27e8(%rip), %rdi     # 0x6351
callq 0x5670
movq 0xa943(%rip), %rdi      # 0x13488
callq 0x5390
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa5ba(%rip), %rax      # 0x13470
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x8ecb
cmpl $0x0, 0x17c(%rax)
je 0x8ecc
retq
xorl %ecx, %ecx
cmpl $0x0, 0x180(%rax)
sete %cl
movl %ecx, 0x180(%rax)
je 0x8ecb
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_O2/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 0xa568(%rip), %rdi      # 0x13470
movl 0x58(%rdi), %edx
cmpl 0x60(%rdi,%rdx,4), %esi
jne 0x8f12
retq
xorq $0x1, %rdx
movl %edx, 0x58(%rdi)
andl (%rax), %ecx
je 0x958e
movl %ecx, 0x60(%rdi,%rdx,4)
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/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 0xa50b(%rip), %rax      # 0x13468
cmpq $0x0, 0x90(%rax)
je 0x8f9b
movl (%rdi), %edi
callq 0xc17c
movq %rax, %rbx
movq 0xa4f8(%rip), %rax      # 0x13470
cmpq %rax, %rbx
je 0x8f9b
movq 0x80(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x99e0
movq %rbx, 0xa4dd(%rip)      # 0x13470
xorl %edi, %edi
popq %rbx
jmp 0x97fb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa48e(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rcx
leaq 0x80cc(%rip), %rsi      # 0x110c0
movq %rcx, %rax
subq %rsi, %rax
pushq $0x18
popq %rdi
xorl %edx, %edx
divq %rdi
movq %rdx, %rax
negq %rax
cmpq $0x0, 0x8(%rcx,%rax)
je 0x9028
subq %rdx, %rcx
cmpq $0x0, 0x20(%rcx)
je 0x9028
addq $0x18, %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
jmp 0x9030
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
callq 0xc1c8
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa42b(%rip), %rax      # 0x13470
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rsi
leaq 0x8069(%rip), %rax      # 0x110c0
movq %rsi, %rcx
subq %rax, %rcx
pushq $0x18
popq %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdx, %rcx
je 0x9085
subq %rdx, %rsi
cmpq $0x0, -0x10(%rsi)
je 0x9085
addq $-0x18, %rsi
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
jmp 0x9094
leaq 0x80ac(%rip), %rax      # 0x11138
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xc1c8
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa3ca(%rip), %rax      # 0x13470
movq 0x78(%rax), %rbx
testq %rbx, %rbx
je 0x90ea
movl 0x5c(%rax), %ecx
movq 0xa0(%rax,%rcx,8), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
sete %dl
leaq -0x201d(%rip), %rsi     # 0x70ae
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x90ea
movq 0x80(%rax), %rax
testq %rax, %rax
je 0x90ec
cmpl $0x0, 0x168(%rax)
je 0x90ec
popq %rbx
retq
movq %rbx, %rdi
callq 0xb864
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x9105
callq 0x97fb
movq 0x1a0(%rbx), %rdi
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x9135
movq %rax, %rcx
movq 0x190(%rax), %rax
testq %rax, %rax
jne 0x9115
movq %rbx, 0x190(%rcx)
andq $0x0, 0x190(%rbx)
jmp 0x9141
andq $0x0, 0x190(%rbx)
movq %rbx, 0x78(%rdi)
popq %rbx
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/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 0xa322(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x9179
pushq %rax
cmpl $0x0, 0x168(%rax)
je 0x917a
leaq 0x168(%rax), %rcx
xorl %edx, %edx
cmpl $0x0, 0x164(%rax)
setne %dl
jmp 0x918f
retq
cmpl $0x0, 0x164(%rax)
je 0x9197
addq $0x168, %rax            # imm = 0x168
pushq $0x1
popq %rdx
movq %rax, %rcx
movl %edx, (%rcx)
popq %rax
jmp 0x958e
movl 0x108(%rax), %esi
movl 0x10c(%rax), %edx
movl 0x128(%rax), %ecx
movl 0x12c(%rax), %r8d
movq %rax, %rdi
callq 0x740d
movq 0xa2b1(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rax
leaq 0x168(%rax), %rcx
cmpl $0x0, 0x168(%rax)
jne 0x916b
pushq $0x1
popq %rdx
jmp 0x918f
// File: /workspace/github_c_makefile_star2_O2/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 0xa28d(%rip), %rbx      # 0x13470
testq %rdi, %rdi
je 0x9252
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x9252
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 0x922c
movl %eax, 0x5c(%rbx)
movl %eax, %eax
movq %rdx, 0xa0(%rbx,%rax,8)
movq 0xa24e(%rip), %rbx      # 0x13470
andq $0x0, 0xb0(%rbx)
jmp 0x9252
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 0xa21e(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x5600
cmpq $0x0, 0x80(%rbx)
je 0x927f
movq %rbx, %rdi
popq %rbx
jmp 0x958e
movq %rbx, %rdi
popq %rbx
jmp 0x76a3
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x18, %rsp
movq 0xa1db(%rip), %rax      # 0x13470
testq %rax, %rax
je 0x9343
movq 0x80(%rax), %rbx
testq %rbx, %rbx
je 0x9343
cmpl $0x0, 0x160(%rbx)
movq 0xa1cc(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq 0xa206(%rip), %rdx      # 0x134d0
je 0x934a
andl $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
callq 0x5650
andl $0x0, 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 0x740d
jmp 0x93ce
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
pushq $0x1
popq %rbp
movl %ebp, 0x8(%rsp)
leaq 0xa180(%rip), %rax      # 0x134d8
movq %rax, (%rsp)
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %r9d, %r9d
callq 0x5650
movl %ebp, 0x160(%rbx)
movl 0x150(%rbx), %eax
movl 0x168(%rbx), %ecx
movl %ecx, 0x188(%rbx)
movl %eax, 0x154(%rbx)
andl $0x0, 0x150(%rbx)
movl %ebp, 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 0x740d
cmpl $0x0, 0x174(%rbx)
jne 0x93ce
movq 0xa0c6(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x1a0(%rbx), %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/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 0xa048(%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 0x943b
retq
xorl %edx, %esi
movl %esi, 0x60(%rdi,%rcx,4)
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/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 0xa020(%rip), %rdi      # 0x13470
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x946d
movl 0x15c(%rcx), %edx
movl $0x1ff, %esi            # imm = 0x1FF
andl (%rax), %esi
cmpl %esi, %edx
jne 0x946e
retq
xorl %edx, %esi
movl %esi, 0x15c(%rcx)
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: restart
void
restart(const Arg *arg)
{
   fprintf(stderr, "restarting dwm..");
   systray_freeicons();
   if (arg->v) {
      execvp(((char **)arg->v)[0], (char **)arg->v);
   } else {
      execlp("dwm", "dwm", "-r", NULL);
   }
   systray_acquire();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8b62(%rip), %rax      # 0x11fe8
movq (%rax), %rcx
leaq 0x4ab8(%rip), %rdi      # 0xdf48
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x56c0
callq 0x82b9
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x94b2
movq (%rsi), %rdi
callq 0x5120
jmp 0x94cc
leaq 0x4048(%rip), %rdi      # 0xd501
leaq 0x3bdf(%rip), %rdx      # 0xd09f
movq %rdi, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x51e0
popq %rbx
jmp 0x6738
// File: /workspace/github_c_makefile_star2_O2/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 0x958d
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $-0x1, %esi
je 0x94f4
cmpl %esi, %eax
jne 0x94fc
jmp 0x9588
xorl %esi, %esi
testl %eax, %eax
sete %sil
movl %esi, 0x68(%rbx)
movq %rbx, %rdi
callq 0x69ca
movq 0x9f7a(%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 0x958e
cmpl $0x0, 0xb8(%rbx)
je 0x9588
cmpl $0x0, 0x68(%rbx)
je 0x9565
leaq 0x8(%rsp), %rcx
andl $0x0, 0x4(%rcx)
movq 0x9f39(%rip), %rdi      # 0x13488
movq 0x9f42(%rip), %rsi      # 0x13498
pushq $0x2
popq %rdx
callq 0x50d0
callq 0x960f
jmp 0x9588
xorl %eax, %eax
subl 0x24(%rbx), %eax
leaq 0x8(%rsp), %rcx
movl %eax, 0x4(%rcx)
movq 0x9f0f(%rip), %rdi      # 0x13488
movq 0x9f18(%rip), %rsi      # 0x13498
pushq $0x2
popq %rdx
callq 0x50d0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x95c1
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
callq 0x971f
xorl %edi, %edi
callq 0x97fb
testq %rbx, %rbx
je 0x95e7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x99a5
leaq 0x9ea0(%rip), %r14      # 0x13468
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x95a6
movq 0x88(%r14), %rdi
callq 0x971f
addq $0x90, %r14
jmp 0x95ca
leaq 0x9e7a(%rip), %rbx      # 0x13468
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9607
movq %rbx, %rdi
callq 0x99a5
addq $0x90, %rbx
jmp 0x95ee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x9e4a(%rip), %rbx      # 0x13468
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9638
cmpl $0x0, 0xb8(%rbx)
jne 0x9638
addq $0x90, %rbx
jmp 0x961e
movl 0x20(%rbx), %ebp
movq 0x9e4e(%rip), %r12      # 0x13490
testq %r12, %r12
je 0x96f7
movl 0x2c(%rbx), %r14d
pushq $0x1
popq %r15
testq %r12, %r12
je 0x96a4
movq 0x9e29(%rip), %rdi      # 0x13488
movq (%r12), %rsi
callq 0x5420
movq 0x9e19(%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
jmp 0x9653
subl %r15d, %ebp
movq 0x9dda(%rip), %rdi      # 0x13488
movq 0x9de3(%rip), %rsi      # 0x13498
movl 0x24(%rbx), %r9d
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x53a0
movq 0x9dbb(%rip), %rdi      # 0x13488
movq 0x9dc4(%rip), %rsi      # 0x13498
callq 0x5710
movq 0x9da8(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x76a3
decl %ebp
movq 0x9d88(%rip), %rdi      # 0x13488
movq 0x9d91(%rip), %rsi      # 0x13498
pushq $0x1
popq %r8
movl %ebp, %edx
xorl %ecx, %ecx
movl %r8d, %r9d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x53a0
// File: /workspace/github_c_makefile_star2_O2/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 0x97c5
cmpl $0x0, 0x180(%rbx)
jne 0x974b
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x97c7
movq 0x9d36(%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 0x978c
cmpl $0x0, 0x168(%rbx)
je 0x97b9
cmpl $0x0, 0x160(%rbx)
jne 0x97b9
movl 0x108(%rbx), %esi
movl 0x10c(%rbx), %edx
movl 0x110(%rbx), %ecx
movl 0x114(%rbx), %r8d
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x7197
movq 0x198(%rbx), %rbx
jmp 0x9723
popq %rbx
retq
movq 0x198(%rbx), %rdi
callq 0x971f
movq 0x9cae(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movl 0x9e85(%rip), %edx      # 0x1366c
addl %edx, %edx
addl 0x108(%rbx), %edx
movl 0x10c(%rbx), %ecx
popq %rbx
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O2/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, 0x9c7d(%rip)      # 0x13480
je 0x9806
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x983a
cmpl $0x0, 0x180(%rbx)
jne 0x9831
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x983a
cmpl $0x0, 0x17c(%rbx)
je 0x9881
movl $0x88, %ebx
addq 0x9c2a(%rip), %rbx      # 0x13470
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x987f
cmpl $0x0, 0x180(%rbx)
jne 0x986d
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %ecx
movl 0x60(%rax,%rcx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9876
cmpl $0x0, 0x17c(%rbx)
je 0x9881
addq $0x198, %rbx            # imm = 0x198
jmp 0x9846
xorl %ebx, %ebx
leaq 0x9be0(%rip), %r14      # 0x13468
movq (%r14), %r14
testq %r14, %r14
je 0x98b1
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x98a8
cmpq %rbx, %rdi
je 0x98a8
xorl %esi, %esi
callq 0x99e0
addq $0x90, %r14
jmp 0x9888
testq %rbx, %rbx
je 0x996e
movq 0x1a0(%rbx), %rdi
cmpq 0x9ba8(%rip), %rdi      # 0x13470
je 0x98cf
callq 0x9a34
cmpl $0x0, 0x184(%rbx)
je 0x991c
andl $0x0, 0x184(%rbx)
movq 0x9ba2(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5430
testq %rax, %rax
je 0x991c
movq %rax, %r14
andb $-0x2, 0x1(%rax)
movq 0x9b83(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
movq %rax, %rdx
callq 0x5780
movq %r14, %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x9a5b
movq 0x1a0(%rbx), %rax
movq 0x88(%rax), %rcx
movq %rcx, 0x198(%rbx)
movq %rbx, 0x88(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9ae1
movq 0x9b36(%rip), %rdi      # 0x13488
leaq 0x1a8(%rbx), %r14
movq 0x1a8(%rbx), %rsi
movq 0x9bb1(%rip), %rdx      # 0x13518
callq 0x52e0
jmp 0x9977
leaq 0x9cdb(%rip), %r14      # 0x13650
xorl %ebx, %ebx
movq 0x9b0a(%rip), %rdi      # 0x13488
movq (%r14), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x54a0
movq 0x9ade(%rip), %rax      # 0x13470
movq %rbx, 0x80(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7680
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdx
callq 0x5600
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x99d1
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa075
// File: /workspace/github_c_makefile_star2_O2/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 0x9a33
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %esi, %esi
callq 0x9ae1
movq 0x9a8c(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x9af6(%rip), %rdx      # 0x13500
callq 0x52e0
testl %ebx, %ebx
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
je 0x9a33
movq 0x9a66(%rip), %rdi      # 0x13488
movq 0x9c27(%rip), %rsi      # 0x13650
pushq $0x1
popq %rdx
xorl %ecx, %ecx
jmp 0x54a0
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: detachstack
void
detachstack(Client *c) {
   Client **tc, *t;

   for(tc = &c->mon->stack; *tc && *tc != c; tc = &(*tc)->snext);
   *tc = c->snext;

   if(c == c->mon->sel) {
      for(t = c->mon->stack; t && (!ISVISIBLE(t) || t->iswidget); t = t->snext);
      c->mon->sel = t;
   }
}

// Assembly:
movl $0x88, %ecx
addq 0x1a0(%rdi), %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x9a7e
leaq 0x198(%rdx), %rcx
cmpq %rdi, %rdx
jne 0x9a67
movq 0x198(%rdi), %rcx
movq %rcx, (%rax)
movq 0x1a0(%rdi), %rax
cmpq %rdi, 0x80(%rax)
je 0x9a99
retq
leaq 0x88(%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x9ad9
cmpl $0x0, 0x180(%rcx)
jne 0x9ac7
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x9ad0
cmpl $0x0, 0x170(%rcx)
je 0x9ad9
addq $0x198, %rcx            # imm = 0x198
jmp 0x9aa0
movq %rcx, 0x80(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: grabbuttons
void
grabbuttons(Client *c, Bool focused) {
   updatenumlockmask();
   {
      unsigned int i, j;
      unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
      XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
      if(focused) {
         for(i = 0; i < LENGTH(buttons); i++)
            if(buttons[i].click == ClkClientWin)
               for(j = 0; j < LENGTH(modifiers); j++)
                  XGrabButton(dpy, buttons[i].button,
                        buttons[i].mask | modifiers[j],
                        c->win, False, BUTTONMASK,
                        GrabModeAsync, GrabModeSync, None, None);
      }
      else
         XGrabButton(dpy, AnyButton, AnyModifier, c->win, False,
               BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x83db
movabsq $0x200000000, %rax      # imm = 0x200000000
movq %rax, 0x20(%rsp)
movl 0x9d0a(%rip), %eax      # 0x13818
movl %eax, 0x28(%rsp)
orl $0x2, %eax
movl %eax, 0x2c(%rsp)
movq 0x9968(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5720
testl %ebp, %ebp
je 0x9bae
xorl %r14d, %r14d
leaq 0x932f(%rip), %r15      # 0x12e70
pushq $0xc
popq %rbp
cmpq $0xf, %r14
je 0x9be3
movq %r14, %r12
shlq $0x5, %r12
cmpl $0x4, (%r12,%r15)
jne 0x9ba9
addq %r15, %r12
xorl %r13d, %r13d
cmpq $0x4, %r13
je 0x9ba9
movq 0x9919(%rip), %rdi      # 0x13488
movl 0x8(%r12), %esi
movl 0x20(%rsp,%r13,4), %edx
orl 0x4(%r12), %edx
movq 0x1a8(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x5630
incq %r13
jmp 0x9b62
incq %r14
jmp 0x9b44
movq 0x98d3(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
pushq $0xc
popq %r9
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
callq 0x5630
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: focusonclick
void
focusonclick(const Arg *arg) {
   int x, w;
   Monitor *m = selmon;
   Client *c, *firstvis;

   for(c = m->clients; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
   firstvis = c;

   x=m->titlebarbegin;

   c = firstvis;
   while(x < m->titlebarend) {
      if(c) {
         w = c->tw;
         if (x < arg->i && x+w > arg->i) {
            focus(c);
            if(c->isfloating)
               XRaiseWindow(dpy, c->win);
            restack(selmon);

            break;
         } else
            x+=w;

         for(c = c->next; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
      }
      else {
         break;
      }
   }

}

// Assembly:
pushq %rbx
movq 0x9876(%rip), %rcx      # 0x13470
leaq 0x78(%rcx), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9c37
cmpl $0x0, 0x180(%rbx)
jne 0x9c25
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %edx
movl 0x60(%rax,%rdx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9c2e
cmpl $0x0, 0x170(%rbx)
je 0x9c37
addq $0x190, %rbx            # imm = 0x190
jmp 0x9bfe
movl 0xd0(%rcx), %eax
movl 0xd4(%rcx), %ecx
testq %rbx, %rbx
je 0x9c9a
cmpl %ecx, %eax
jge 0x9c9a
movl (%rdi), %edx
cmpl %edx, %eax
setl %sil
addl 0x158(%rbx), %eax
cmpl %edx, %eax
setg %dl
testb %dl, %sil
jne 0x9c9c
movq 0x190(%rbx), %rbx
testq %rbx, %rbx
je 0x9c43
cmpl $0x0, 0x180(%rbx)
jne 0x9c8f
movq 0x1a0(%rbx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rbx)
je 0x9c64
cmpl $0x0, 0x170(%rbx)
jne 0x9c64
jmp 0x9c43
popq %rbx
retq
movq %rbx, %rdi
callq 0x97fb
cmpl $0x0, 0x168(%rbx)
je 0x9cc0
movq 0x97d4(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x97a9(%rip), %rdi      # 0x13470
popq %rbx
jmp 0xa075
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: closeonclick
void
closeonclick(const Arg *arg) {
   int x, w;
   Monitor *m = selmon;
   Client *c, *firstvis;

   for(c = m->clients; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
   firstvis = c;

   x=m->titlebarbegin;

   c = firstvis;
   while(x < m->titlebarend) {
      if(c) {
         w = c->tw;
         if (x < arg->i && x+w > arg->i) {
            focus(c);
            restack(selmon);
            killclient(0);
            break;
         } else
            x+=w;

         for(c = c->next; c && (!ISVISIBLE(c) || c->iswidget); c = c->next);
      }
      else {
         break;
      }
   }
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq 0x9798(%rip), %rdx      # 0x13470
leaq 0x78(%rdx), %rdi
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9d15
cmpl $0x0, 0x180(%rdi)
jne 0x9d03
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %esi
movl 0x60(%rcx,%rsi,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0x9d0c
cmpl $0x0, 0x170(%rdi)
je 0x9d15
addq $0x190, %rdi            # imm = 0x190
jmp 0x9cdc
movl 0xd0(%rdx), %ecx
movl 0xd4(%rdx), %edx
testq %rdi, %rdi
je 0x9d7b
cmpl %edx, %ecx
jge 0x9d7b
movl (%rax), %esi
cmpl %esi, %ecx
setl %r8b
addl 0x158(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %r8b
jne 0x9d7d
movq 0x190(%rdi), %rdi
testq %rdi, %rdi
je 0x9d21
cmpl $0x0, 0x180(%rdi)
jne 0x9d70
movq 0x1a0(%rdi), %rsi
movl 0x58(%rsi), %r8d
movl 0x60(%rsi,%r8,4), %esi
testl %esi, 0x15c(%rdi)
je 0x9d43
cmpl $0x0, 0x170(%rdi)
jne 0x9d43
jmp 0x9d21
popq %rax
retq
callq 0x97fb
movq 0x96e7(%rip), %rdi      # 0x13470
callq 0xa075
popq %rax
jmp 0x89a4
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: sendmon
void
sendmon(Client *c, Monitor *m) {
   if(c->mon == m)
      return;
   unfocus(c, True);
   detach(c);
   detachstack(c);
   c->mon = m;
   c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
   attach(c);
   attachstack(c);
   focus(NULL);
   arrange(NULL);
}

// Assembly:
cmpq %rsi, 0x1a0(%rdi)
je 0xa2ca
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x99e0
movq %r14, %rdi
callq 0xb864
movq %r14, %rdi
callq 0x9a5b
movq %rbx, 0x1a0(%r14)
movl 0x58(%rbx), %eax
movl 0x60(%rbx,%rax,4), %eax
movl %eax, 0x15c(%r14)
movq 0x78(%rbx), %rax
movq %rax, 0x190(%r14)
movq %r14, 0x78(%rbx)
movq 0x88(%rbx), %rax
movq %rax, 0x198(%r14)
movq %r14, 0x88(%rbx)
xorl %edi, %edi
callq 0x97fb
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x958e
retq