LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbe2b
jmp 0xbf25
cmpl $-0x1, -0xc(%rbp)
je 0xbe4e
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xbe42
jmp 0xbf25
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
jmp 0xbe67
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rdi
callq 0x71d0
movq 0xc7a1(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x24(%rax), %r9d
callq 0x53b0
movq -0x8(%rbp), %rdi
callq 0xbf30
movq -0x8(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
je 0xbf25
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0xbeef
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x24(%rcx), %eax
movl %eax, -0x34(%rbp)
movq 0xc740(%rip), %rdi      # 0x18618
movq 0xc749(%rip), %rsi      # 0x18628
movl $0x2, %edx
leaq -0x38(%rbp), %rcx
callq 0x50e0
jmp 0xbf23
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0xbf21
movl $0x0, -0x34(%rbp)
movq 0xc711(%rip), %rdi      # 0x18618
movq 0xc71a(%rip), %rsi      # 0x18628
movl $0x2, %edx
leaq -0x38(%rbp), %rcx
callq 0x50e0
callq 0xbfe0
jmp 0xbf23
jmp 0xbf25
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbf55
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xc170
jmp 0xbf8a
movq 0xc69c(%rip), %rax      # 0x185f8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbf88
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0xc170
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbf60
jmp 0xbf8a
xorl %eax, %eax
movl %eax, %edi
callq 0xc2d0
cmpq $0x0, -0x8(%rbp)
je 0xbfa5
movq -0x8(%rbp), %rdi
callq 0xc520
jmp 0xbfd3
movq 0xc64c(%rip), %rax      # 0x185f8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbfd1
movq -0x8(%rbp), %rdi
callq 0xc520
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbfb0
jmp 0xbfd3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, -0x14(%rbp)
movl 0xc807(%rip), %eax      # 0x187fc
movl %eax, -0x18(%rbp)
movq 0xc5f9(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1d(%rbp)
je 0xc022
movq -0x10(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xc02b
jmp 0xc03e
jmp 0xc02d
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xc003
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, 0xc5c6(%rip)      # 0x18620
jne 0xc08b
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq 0xc5ac(%rip), %rdi      # 0x18618
movq 0xc5b5(%rip), %rsi      # 0x18628
movl -0x18(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x53b0
jmp 0xc15e
movq 0xc58e(%rip), %rax      # 0x18620
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc104
movq 0xc574(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5430
movq 0xc561(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movw %ax, 0x8(%rcx)
movswl %ax, %edx
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %r8d
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %r9d
xorl %ecx, %ecx
callq 0x53b0
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %eax
addl $0x2, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc096
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq 0xc502(%rip), %rdi      # 0x18618
movq 0xc50b(%rip), %rsi      # 0x18628
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %r8d
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r9d
callq 0x53b0
movq 0xc4dd(%rip), %rdi      # 0x18618
movq 0xc4e6(%rip), %rsi      # 0x18628
callq 0x5720
movq 0xc4ca(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
movq -0x10(%rbp), %rdi
callq 0x8b10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc188
jmp 0xc2be
movq -0x8(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xc1c5
movq -0x8(%rbp), %rax
movl 0x15c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0xc279
movq 0xc44c(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x108(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %ecx
callq 0x5080
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0xc225
movq -0x8(%rbp), %rax
cmpl $0x0, 0x168(%rax)
je 0xc267
movq -0x8(%rbp), %rax
cmpl $0x0, 0x160(%rax)
jne 0xc267
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x108(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x110(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x114(%rax), %r8d
xorl %r9d, %r9d
callq 0x8060
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0xc170
jmp 0xc2be
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rdi
callq 0xc170
movq 0xc388(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x108(%rax), %edx
movl 0xc551(%rip), %eax      # 0x187fc
shll %eax
addl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %ecx
callq 0x5080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
callq 0x5620
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
cmpq $0x0, 0x10(%rax)
je 0xc588
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0xd1b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xc5b8
jmp 0xc603
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xc860
movq 0xc04e(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movq 0xc0b4(%rip), %rdx      # 0x18690
callq 0x52f0
cmpl $0x0, -0xc(%rbp)
je 0xc603
movq 0xc02a(%rip), %rdi      # 0x18618
movq 0xc1eb(%rip), %rsi      # 0x187e0
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x54b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: clearurgent
void
clearurgent(Client *c) {
   XWMHints *wmh;

   c->isurgent = False;
   if(!(wmh = XGetWMHints(dpy, c->win)))
      return;
   wmh->flags &= ~XUrgencyHint;
   XSetWMHints(dpy, c->win, wmh);
   XFree(wmh);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x184(%rax)
movq 0xbf97(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
callq 0x5440
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xc69d
jmp 0xc6d2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x101, %rcx           # imm = 0xFEFF
movq %rcx, (%rax)
movq 0xbf63(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x5790
movq -0x10(%rbp), %rdi
callq 0x5070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
addq $0x88, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0xc71d
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc726
jmp 0xc73b
jmp 0xc728
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x198, %rax            # imm = 0x198
movq %rax, -0x10(%rbp)
jmp 0xc6fd
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
cmpq 0x80(%rcx), %rax
jne 0xc812
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1a(%rbp)
je 0xc7e0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xc7c9
movq -0x18(%rbp), %rax
movl 0x15c(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rax,%rdx,4), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1b(%rbp)
je 0xc7da
movq -0x18(%rbp), %rax
cmpl $0x0, 0x170(%rax)
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xc7e9
jmp 0xc7fc
jmp 0xc7eb
movq -0x18(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc77f
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rcx, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xa2f0
movl $0x0, -0x30(%rbp)
movl $0x2, -0x2c(%rbp)
movl 0xc0e0(%rip), %eax      # 0x18968
movl %eax, -0x28(%rbp)
movl 0xc0d7(%rip), %eax      # 0x18968
orl $0x2, %eax
movl %eax, -0x24(%rbp)
movq 0xbd7a(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5730
cmpl $0x0, -0xc(%rbp)
je 0xc99b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0xf, %rax
jae 0xc999
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xb5f1(%rip), %rax      # 0x17ed0
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x4, (%rax)
jne 0xc989
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x4, %rax
jae 0xc987
movq 0xbd0e(%rip), %rdi      # 0x18618
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xb5ba(%rip), %rax      # 0x17ed0
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xb5a4(%rip), %rax      # 0x17ed0
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movl -0x14(%rbp), %eax
orl -0x30(%rbp,%rax,4), %edx
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rcx
xorl %r8d, %r8d
movl $0xc, %r9d
xorl %eax, %eax
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x5650
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc8f6
jmp 0xc989
jmp 0xc98b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc8c6
jmp 0xc9e6
movq 0xbc76(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rcx
xorl %r8d, %r8d
movl $0x8000, %edx           # imm = 0x8000
movl $0xc, %r9d
xorl %eax, %eax
movl %r8d, %esi
movl $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x5650
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xba0d(%rip), %rax      # 0x18600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xcc64
movq -0x20(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xcc4d
movq -0x20(%rbp), %rax
movl 0x15c(%rax), %ecx
movq -0x20(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x20(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rax,%rdx,4), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0xcc5e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x170(%rax)
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xcc6d
jmp 0xcc80
jmp 0xcc6f
movq -0x20(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcc03
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0xd0(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xd4(%rcx), %eax
jge 0xcda2
cmpq $0x0, -0x20(%rbp)
je 0xcd9b
movq -0x20(%rbp), %rax
movl 0x158(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcd04
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xcd04
movq -0x20(%rbp), %rdi
callq 0xc2d0
movq 0xb90f(%rip), %rdi      # 0x18600
callq 0xd1b0
xorl %eax, %eax
movl %eax, %edi
callq 0xac90
jmp 0xcda2
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2b(%rbp)
je 0xcd7d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x180(%rax)
jne 0xcd66
movq -0x20(%rbp), %rax
movl 0x15c(%rax), %ecx
movq -0x20(%rbp), %rax
movq 0x1a0(%rax), %rax
movq -0x20(%rbp), %rdx
movq 0x1a0(%rdx), %rdx
movl 0x58(%rdx), %edx
andl 0x60(%rax,%rdx,4), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2c(%rbp)
je 0xcd77
movq -0x20(%rbp), %rax
cmpl $0x0, 0x170(%rax)
setne %al
movb %al, -0x2c(%rbp)
movb -0x2c(%rbp), %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0xcd86
jmp 0xcd99
jmp 0xcd88
movq -0x20(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcd1c
jmp 0xcd9d
jmp 0xcda2
jmp 0xcc9d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xd483
jmp 0xd4ef
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xc5a0
movq -0x8(%rbp), %rdi
callq 0xf910
movq -0x8(%rbp), %rdi
callq 0xc6e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1a0(%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x58(%rcx), %ecx
movl 0x60(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x15c(%rax)
movq -0x8(%rbp), %rdi
callq 0x109b0
movq -0x8(%rbp), %rdi
callq 0xc820
xorl %eax, %eax
movl %eax, %edi
callq 0xc2d0
xorl %eax, %eax
movl %eax, %edi
callq 0xbf30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: motionnotify
void
motionnotify(XEvent *e) {
   Monitor *m;
   menu_t  *mm;
   XMotionEvent *ev = &e->xmotion;

   if( (mm = wintomenu(ev->window)) )
   {
      updatemenu(mm, ev->x, ev->y);
      return;
   }

   if(!autofocusmonitor)
      return;

   if((m = ptrtomon(ev->x_root, ev->y_root)))
      if(m != selmon) { focusmon(m); drawbars(); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x58c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdb54
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x40(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x44(%rax), %edx
callq 0xeaa0
jmp 0xdb8e
movq -0x20(%rbp), %rax
movl 0x48(%rax), %edi
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x88b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdb8e
movq -0x10(%rbp), %rax
cmpq 0xaa84(%rip), %rax      # 0x18600
je 0xdb8c
movq -0x10(%rbp), %rdi
callq 0xc610
callq 0x8ad0
jmp 0xdb8e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: enternotify
void
enternotify(XEvent *e) {
   Client *c;
   Monitor *m;
   XCrossingEvent *ev = &e->xcrossing;

   if((ev->mode != NotifyNormal || ev->detail == NotifyInferior))
      return;

   if(!autofocusmonitor)
   {
      if((m = wintomon(ev->window)) && m != selmon) {
         unfocus(selmon->sel, True);
         focusmon(m);
      }
   }
   else
   {
      if((m = wintomon(ev->window)) && m != selmon)
      { focusmon(m); drawbars(); }
   }

   if(!clicktofocus)
   {
      if((c = wintoclient(ev->window)))
         focus(c);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0xdbc8
movq -0x20(%rbp), %rax
cmpl $0x2, 0x54(%rax)
jne 0xdbca
jmp 0xdbfc
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x72c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdbfc
movq -0x18(%rbp), %rax
cmpq 0xaa14(%rip), %rax      # 0x18600
je 0xdbfc
movq -0x18(%rbp), %rdi
callq 0xc610
callq 0x8ad0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: focusin
void
focusin(XEvent *e) { /* there are some broken focus acquiring clients */
   XFocusChangeEvent *ev = &e->xfocus;

   if(selmon->sel && ev->window != selmon->sel->win)
      XSetInputFocus(dpy, selmon->sel->win, RevertToPointerRoot, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xa9d5(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
je 0xdc7e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0xa9bc(%rip), %rcx      # 0x18600
movq 0x80(%rcx), %rcx
cmpq 0x1a8(%rcx), %rax
je 0xdc7e
movq 0xa9bd(%rip), %rdi      # 0x18618
movq 0xa99e(%rip), %rax      # 0x18600
movq 0x80(%rax), %rax
movq 0x1a8(%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x54b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: expose
void
expose(XEvent *e) {
   Monitor *m;
   XExposeEvent *ev = &e->xexpose;

   if(ev->count == 0 && (m = wintomon(ev->window)))
   { drawbar(m); if(m->primary) systray_update(); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0xdce2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x72c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdce2
movq -0x10(%rbp), %rdi
callq 0x8b10
movq -0x10(%rbp), %rax
cmpl $0x0, 0xb8(%rax)
je 0xdce0
callq 0xbfe0
jmp 0xdce2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: destroynotify
void
destroynotify(XEvent *e) {
   Client *c;
   Systray *s;
   XDestroyWindowEvent *ev = &e->xdestroywindow;

   if((c = wintoclient(ev->window)))
      unmanage(c, True);

   if((s = systray_find(ev->window))){
      systray_del(s);
      systray_update();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8940
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdd29
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf710
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xf840
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdd4e
movq -0x18(%rbp), %rdi
callq 0xf890
callq 0xbfe0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: unmapnotify
void
unmapnotify(XEvent *e) {
   Client *c;
   Systray *s;
   XUnmapEvent *ev = &e->xunmap;

   if((c = wintoclient(ev->window)))
      unmanage(c, False);

   if((s = systray_find(ev->window)))
   {
      systray_del(s);
      systray_update();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8940
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdd96
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xf710
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xf840
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xddbb
movq -0x18(%rbp), %rdi
callq 0xf890
callq 0xbfe0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: maprequest
void
maprequest(XEvent *e) {
   static XWindowAttributes wa;
   XMapRequestEvent *ev = &e->xmaprequest;
   Systray *s;

   if((s = systray_find(ev->window)))
   {
      dwm_send_message(s->win, s->win, "_XEMBED", CurrentTime, XEMBED_WINDOW_ACTIVATE , 0, 0, 0);

      systray_update();
   }

   if(!XGetWindowAttributes(dpy, ev->window, &wa))
      return;
   if(wa.override_redirect)
      return;
   if(!wintoclient(ev->window))
      manage(ev->window, &wa);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xf840
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xde39
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x48eb(%rip), %rdx      # 0x126fb
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %r8d
movq %r9, %rcx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xa230
callq 0xbfe0
movq 0xa7d8(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0xab29(%rip), %rdx      # 0x18978
callq 0x5660
cmpl $0x0, %eax
jne 0xde5b
jmp 0xde8d
cmpl $0x0, 0xab8e(%rip)      # 0x189f0
je 0xde66
jmp 0xde8d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8940
cmpq $0x0, %rax
jne 0xde8d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0xaaf0(%rip), %rsi      # 0x18978
callq 0xfa00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: configurenotify
void
configurenotify(XEvent *e) {
   Monitor *m;
   XConfigureEvent *ev = &e->xconfigure;

   if(ev->window == root) {
      sw = ev->width;
      sh = ev->height;
      if(updategeom()) {
         if(dc.drawable != 0)
            XFreePixmap(dpy, dc.drawable);
         dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
#ifdef XFT
         XftDrawChange(dc.xftdrawable, dc.drawable);
#endif
         updatebars();
         for(m = mons; m; m = m->next)
            XMoveResizeWindow(dpy, m->barwin, m->bx, m->by, m->bw, m->bh);
         arrange(NULL);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0xa91d(%rip), %rax      # 0x187e0
jne 0xdfbc
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0xa926(%rip)      # 0x187fc
movq -0x18(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, 0xa91d(%rip)      # 0x18800
callq 0x6910
cmpl $0x0, %eax
je 0xdfba
cmpq $0x0, 0xa8b7(%rip)      # 0x187b0
je 0xdf0e
movq 0xa716(%rip), %rdi      # 0x18618
movq 0xa8a7(%rip), %rsi      # 0x187b0
callq 0x56a0
movq 0xa703(%rip), %rdi      # 0x18618
movq 0xa8c4(%rip), %rsi      # 0x187e0
movl 0xa8da(%rip), %edx      # 0x187fc
movl 0xa8dc(%rip), %ecx      # 0x18804
movq 0xa6e9(%rip), %rax      # 0x18618
movq 0xe8(%rax), %rax
movslq 0xa8bb(%rip), %r8       # 0x187f8
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x5710
movq %rax, 0xa85c(%rip)      # 0x187b0
callq 0x6bd0
movq 0xa698(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdfb1
movq 0xa6a6(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r9d
callq 0x53b0
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xdf64
xorl %eax, %eax
movl %eax, %edi
callq 0xbf30
jmp 0xdfbc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: propertynotify
void
propertynotify(XEvent *e) {
   Client *c;
   Systray *s;
   Window trans;
   XPropertyEvent *ev = &e->xproperty;

   if((s = systray_find(ev->window)))
   {
      systray_state(s);
      systray_update();
   }

   if((ev->window == root) && (ev->atom == XA_WM_NAME))
      updatestatus();
   else if(ev->state == PropertyDelete)
      return; /* ignore */
   else if((c = wintoclient(ev->window))) {
      switch (ev->atom) {
         default: break;
         case XA_WM_TRANSIENT_FOR:
                  XGetTransientForHint(dpy, c->win, &trans);
                  if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
                     arrange(c->mon);
                  break;
         case XA_WM_NORMAL_HINTS:
                  updatesizehints(c);
                  break;
         case XA_WM_HINTS:
                  updatewmhints(c);
                  drawbars();
                  break;
      }
      if(ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {
         updatetitle(c);
         if(c == c->mon->sel)
            drawbar(c->mon);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xf840
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xe359
movq -0x18(%rbp), %rdi
callq 0x109f0
callq 0xbfe0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0xa478(%rip), %rax      # 0x187e0
jne 0xe37f
movq -0x28(%rbp), %rax
cmpq $0x27, 0x28(%rax)
jne 0xe37f
callq 0x6d20
jmp 0xe4ab
movq -0x28(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0xe38e
jmp 0xe4ab
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8940
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xe4a7
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
subq $0x23, %rax
je 0xe448
jmp 0xe3c1
movq -0x30(%rbp), %rax
subq $0x28, %rax
je 0xe43d
jmp 0xe3cd
movq -0x30(%rbp), %rax
subq $0x44, %rax
je 0xe3db
jmp 0xe3d9
jmp 0xe456
movq 0xa236(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x56c0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x168(%rax)
jne 0xe43b
movq -0x20(%rbp), %rdi
callq 0x8940
cmpq $0x0, %rax
setne %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x168(%rcx)
testb $0x1, %al
jne 0xe42b
jmp 0xe43b
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0xbf30
jmp 0xe456
movq -0x10(%rbp), %rdi
callq 0x10640
jmp 0xe456
movq -0x10(%rbp), %rdi
callq 0x108f0
callq 0x8ad0
movq -0x28(%rbp), %rax
cmpq $0x27, 0x28(%rax)
je 0xe472
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0xa1e8(%rip), %rax      # 0x18658
jne 0xe4a5
movq -0x10(%rbp), %rdi
callq 0x10280
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x1a0(%rcx), %rcx
cmpq 0x80(%rcx), %rax
jne 0xe4a3
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
callq 0x8b10
jmp 0xe4a5
jmp 0xe4a7
jmp 0xe4a9
jmp 0xe4ab
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: mappingnotify
void
mappingnotify(XEvent *e) {
   XMappingEvent *ev = &e->xmapping;

   XRefreshKeyboardMapping(ev);
   if(ev->request == MappingKeyboard)
      grabkeys();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50f0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0xe79c
callq 0x6fc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: menu_up
void
menu_up(const Arg *arg) {
   size_t i;
   cmenu->sel--;
   if(cmenu->sel < 0)
      for(i = 0; cmenu->ctx[i].title; i++) cmenu->sel = i;
   updatemenu(cmenu, 0, 0);
   while(!strlen(cmenu->ctx[cmenu->sel].title)) menu_up(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa1ad(%rip), %rax      # 0x18970
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
movq 0xa19d(%rip), %rax      # 0x18970
cmpl $0x0, 0x38(%rax)
jge 0xe81d
movq $0x0, -0x10(%rbp)
movq 0xa188(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xe81b
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq 0xa166(%rip), %rax      # 0x18970
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe7e1
jmp 0xe81d
movq 0xa14c(%rip), %rdi      # 0x18970
xorl %edx, %edx
movl %edx, %esi
callq 0xeaa0
movq 0xa13c(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq 0xa131(%rip), %rcx      # 0x18970
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x52d0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe861
jmp 0xe86c
xorl %eax, %eax
movl %eax, %edi
callq 0xe7b0
jmp 0xe82d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: menu_down
void
menu_down(const Arg *arg) {
   cmenu->sel++;
   if(!cmenu->ctx[cmenu->sel].title) cmenu->sel = 0;
   updatemenu(cmenu, 0, 0);
   while(!strlen(cmenu->ctx[cmenu->sel].title)) menu_down(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa0dd(%rip), %rax      # 0x18970
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq 0xa0cd(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq 0xa0c2(%rip), %rcx      # 0x18970
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xe8cd
movq 0xa0aa(%rip), %rax      # 0x18970
movl $0x0, 0x38(%rax)
movq 0xa09c(%rip), %rdi      # 0x18970
xorl %edx, %edx
movl %edx, %esi
callq 0xeaa0
movq 0xa08c(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq 0xa081(%rip), %rcx      # 0x18970
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x52d0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe911
jmp 0xe91c
xorl %eax, %eax
movl %eax, %edi
callq 0xe880
jmp 0xe8dd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: menu_next
void
menu_next(const Arg *arg) {
   if(cmenu->sel > -1)
   {
      if(cmenu->child) { closemenu(cmenu->child); cmenu->child = NULL; }
      if(cmenu->ctx[cmenu->sel].ctx)
      {
         cmenu->child      = openmenupos( cmenu->ctx[cmenu->sel].ctx, cmenu->x + cmenu->w, cmenu->y + cmenu->sely );
         if(!cmenu->child) return;
         cmenu->child->sel = 0;
         updatemenu(cmenu->child, 0, 0);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa02d(%rip), %rax      # 0x18970
cmpl $-0x1, 0x38(%rax)
jle 0xea36
movq 0xa01c(%rip), %rax      # 0x18970
cmpq $0x0, 0x28(%rax)
je 0xe97a
movq 0xa00e(%rip), %rax      # 0x18970
movq 0x28(%rax), %rdi
callq 0xeef0
movq 0x9ffe(%rip), %rax      # 0x18970
movq $0x0, 0x28(%rax)
movq 0x9fef(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq 0x9fe4(%rip), %rcx      # 0x18970
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0xea34
movq 0x9fc7(%rip), %rax      # 0x18970
movq 0x30(%rax), %rax
movq 0x9fbc(%rip), %rcx      # 0x18970
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x9fa6(%rip), %rax      # 0x18970
movl 0x8(%rax), %esi
movq 0x9f9c(%rip), %rax      # 0x18970
addl 0x10(%rax), %esi
movq 0x9f92(%rip), %rax      # 0x18970
movl 0xc(%rax), %edx
movq 0x9f88(%rip), %rax      # 0x18970
addl 0x3c(%rax), %edx
callq 0xf050
movq %rax, %rcx
movq 0x9f76(%rip), %rax      # 0x18970
movq %rcx, 0x28(%rax)
movq 0x9f6b(%rip), %rax      # 0x18970
cmpq $0x0, 0x28(%rax)
jne 0xea0e
jmp 0xea36
movq 0x9f5b(%rip), %rax      # 0x18970
movq 0x28(%rax), %rax
movl $0x0, 0x38(%rax)
movq 0x9f49(%rip), %rax      # 0x18970
movq 0x28(%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xeaa0
jmp 0xea36
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: drawhline
void
drawhline(size_t col_index) {
   XGCValues gcv;

   XRectangle r = { dc.x , dc.y, dc.w , dc.h };
   XSetForeground(dpy, dc.gc, dc.colors[col_index][ColBG]);
   XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);

   gcv.foreground = dc.colors[col_index][ColFG];
   XChangeGC(dpy, dc.gc, GCForeground, &gcv);
   XDrawLine(dpy, dc.drawable, dc.gc, dc.x, dc.y + dc.h / 2, dc.w, dc.y + dc.h / 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl 0x98db(%rip), %eax      # 0x18680
movw %ax, -0x90(%rbp)
movl 0x98d2(%rip), %eax      # 0x18684
movw %ax, -0x8e(%rbp)
movl 0x98c9(%rip), %eax      # 0x18688
movw %ax, -0x8c(%rbp)
movl 0x98c0(%rip), %eax      # 0x1868c
movw %ax, -0x8a(%rbp)
movq 0x983e(%rip), %rdi      # 0x18618
movq 0x99d7(%rip), %rsi      # 0x187b8
leaq 0x9898(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x8(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
callq 0x5340
movq 0x9814(%rip), %rdi      # 0x18618
movq 0x99a5(%rip), %rsi      # 0x187b0
movq 0x99a6(%rip), %rdx      # 0x187b8
leaq -0x90(%rbp), %rcx
movl $0x1, %r8d
callq 0x5320
leaq 0x9855(%rip), %rax      # 0x18680
addq $0x10, %rax
imulq $0x18, -0x8(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq 0x97d2(%rip), %rdi      # 0x18618
movq 0x996b(%rip), %rsi      # 0x187b8
movl $0x4, %edx
leaq -0x88(%rbp), %rcx
callq 0x5510
movq 0x97b3(%rip), %rdi      # 0x18618
movq 0x9944(%rip), %rsi      # 0x187b0
movq 0x9945(%rip), %rax      # 0x187b8
movq %rax, -0xa0(%rbp)
movl 0x9800(%rip), %ecx      # 0x18680
movl 0x97fd(%rip), %r8d      # 0x18684
movl 0x97ff(%rip), %eax      # 0x1868c
movl $0x2, %r9d
cltd
idivl %r9d
addl %eax, %r8d
movl 0x97e7(%rip), %r9d      # 0x18688
movl 0x97dd(%rip), %eax      # 0x18684
movl %eax, -0x94(%rbp)
movl 0x97d9(%rip), %eax      # 0x1868c
movl $0x2, %r10d
cltd
idivl %r10d
movq -0xa0(%rbp), %rdx
movl %eax, %r10d
movl -0x94(%rbp), %eax
addl %r10d, %eax
movl %eax, (%rsp)
callq 0x52e0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: closemenu
static void
closemenu( menu_t *target )
{
   menu_t **m, *mm;

   if(!target) return;

   /* this is not valid child anymore */
   for( mm = menu; mm; mm = mm->next )
      if(mm->child == target) mm->child = NULL;

   /* close childs */
   for( mm = target->child; mm; mm = mm->child )
      closemenu( mm );

   /* remove */
   m = &menu;
   for( mm = menu; mm && mm->next && mm->next != target; mm = mm->next )
      m = &mm;

   (*m)->next = target->next;
   XSetInputFocus(dpy, (*m)->win, RevertToPointerRoot, CurrentTime);

   XFreePixmap(dpy, target->drawable);
   XDestroyWindow(dpy, target->win);
   free(target);
   XSync(dpy, False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xef08
jmp 0xf041
movq 0x9701(%rip), %rax      # 0x18610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xef44
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xef34
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0xef36
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xef13
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xef6e
movq -0x18(%rbp), %rdi
callq 0xeef0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xef50
leaq 0x969b(%rip), %rax      # 0x18610
movq %rax, -0x10(%rbp)
movq 0x9690(%rip), %rax      # 0x18610
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xefb2
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x19(%rbp)
je 0xefb2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xefbb
jmp 0xefd1
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xef84
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x962d(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x54b0
movq 0x960e(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x56a0
movq 0x95fa(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5310
movq -0x8(%rbp), %rdi
callq 0x52b0
movq 0x95de(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: openmenupos
static menu_t*
openmenupos( const menuCtx *ctx, int x, int y ) {
   menu_t **m, *mm;

   m  = &menu;
   mm =  menu;
   for(; mm; mm = mm->next)
      m = &mm->next;

   *m = calloc(1, sizeof(menu_t));
   if(!*m)
      return NULL;

   (*m)->next = NULL;
   if(createmenu(*m, ctx, x, y) == -1)
   { free(*m); *m = NULL; }

   return *m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq 0x95a7(%rip), %rax      # 0x18610
movq %rax, -0x20(%rbp)
movq 0x959c(%rip), %rax      # 0x18610
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xf099
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf078
movl $0x1, %edi
movl $0x40, %esi
callq 0x55c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf0c6
movq $0x0, -0x8(%rbp)
jmp 0xf112
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0xf120
cmpl $-0x1, %eax
jne 0xf107
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x52b0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: buttonmenu
static void
buttonmenu( menu_t *m, int x, int y )
{
   if(!m) return;
   updatemenu(m, x, y);
   if(m->sel == -1)         return;
   if(!m->ctx[m->sel].func) return;

   m->ctx[m->sel].func(&m->ctx[m->sel].arg);
   closemenus();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf60b
jmp 0xf683
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xeaa0
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x38(%rax)
jne 0xf626
jmp 0xf683
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0xf646
jmp 0xf683
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
movq -0x8(%rbp), %rcx
movslq 0x38(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rdi
addq $0x18, %rdi
callq *%rax
callq 0xf690
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: closemenus
static void
closemenus(void) {
   if(!menu) return;

   menu_t *m = menu, *next = NULL;
   while(m)
   {
      XDestroyWindow(dpy, m->win);

      next = m->next; free(m);
      m = next;
   }
   XSync(dpy, False);
   menu = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x8f70(%rip)      # 0x18610
jne 0xf6a4
jmp 0xf709
movq 0x8f65(%rip), %rax      # 0x18610
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf6f0
movq 0x8f53(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5310
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf6b7
movq 0x8f21(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
movq $0x0, 0x8f07(%rip) # 0x18610
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: unmanage
void
unmanage(Client *c, Bool destroyed) {
   Monitor *m = c->mon;
   XWindowChanges wc;

   focusmon(m);
   if(c && c->isfullscreen)
   { if(!m->showbartoggle) togglebarm(m, 1); }

   /* The server grab construct avoids race conditions. */
   detach(c);
   detachstack(c);
   if(!destroyed) {
      wc.border_width = c->oldbw;
      XGrabServer(dpy);
      XSetErrorHandler(xerrordummy);
      XConfigureWindow(dpy, c->win, CWBorderWidth, &wc); /* restore border */
      XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
      setclientstate(c, WithdrawnState);
      XSync(dpy, False);
      XSetErrorHandler(xerror);
      XUngrabServer(dpy);
   }
   free(c);
   focus(NULL);
   arrange(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc610
cmpq $0x0, -0x8(%rbp)
je 0xf765
movq -0x8(%rbp), %rax
cmpl $0x0, 0x160(%rax)
je 0xf765
movq -0x18(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0xf763
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xbe10
jmp 0xf765
movq -0x8(%rbp), %rdi
callq 0xf910
movq -0x8(%rbp), %rdi
callq 0xc6e0
cmpl $0x0, -0xc(%rbp)
jne 0xf817
movq -0x8(%rbp), %rax
movl 0x154(%rax), %eax
movl %eax, -0x30(%rbp)
movq 0x8e83(%rip), %rdi      # 0x18618
callq 0x5100
leaq 0x1df(%rip), %rdi       # 0xf980
callq 0x5690
movq 0x8e6b(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movl $0x10, %edx
leaq -0x40(%rbp), %rcx
callq 0x50e0
movq 0x8e4b(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5730
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf990
movq 0x8e20(%rip), %rdi      # 0x18618
xorl %esi, %esi
callq 0x54d0
leaq -0x92a6(%rip), %rdi     # 0x6560
callq 0x5690
movq 0x8e06(%rip), %rdi      # 0x18618
callq 0x53a0
movq -0x8(%rbp), %rdi
callq 0x52b0
xorl %eax, %eax
movl %eax, %edi
callq 0xc2d0
movq -0x18(%rbp), %rdi
callq 0xbf30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: systray_find
Systray*
systray_find(Window win) {
   Systray *i;

   if(!systray_enable) return NULL;

   for(i = trayicons; i; i = i->next)
      if(i->win == win) return i;

   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x8dd1(%rip), %rax      # 0x18620
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf881
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xf871
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf889
jmp 0xf873
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf853
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop