LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x9dc8
leaq 0x198(%rdx), %rcx
cmpq %rdi, %rdx
jne 0x9db1
movq 0x198(%rdi), %rcx
movq %rcx, (%rax)
movq 0x1a0(%rdi), %rax
cmpq %rdi, 0x80(%rax)
je 0x9de3
retq
movq 0x88(%rax), %rcx
testq %rcx, %rcx
je 0x9e20
cmpl $0x0, 0x180(%rcx)
jne 0x9e0e
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x9e17
cmpl $0x0, 0x170(%rcx)
je 0x9e22
movq 0x198(%rcx), %rcx
jmp 0x9dea
xorl %ecx, %ecx
movq %rcx, 0x80(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x862f
movabsq $0x200000000, %rax      # imm = 0x200000000
movq %rax, 0x20(%rsp)
movl 0x99c1(%rip), %eax      # 0x13818
movl %eax, 0x28(%rsp)
orl $0x2, %eax
movl %eax, 0x2c(%rsp)
movq 0x961f(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5720
testl %ebp, %ebp
je 0x9ef7
xorl %r14d, %r14d
leaq 0x8fe6(%rip), %r15      # 0x12e70
xorps %xmm0, %xmm0
movq %r14, %r12
shlq $0x5, %r12
cmpl $0x4, (%r12,%r15)
jne 0x9eec
addq %r15, %r12
xorl %r13d, %r13d
movq 0x95e0(%rip), %rdi      # 0x13488
movl 0x8(%r12), %esi
movl 0x20(%rsp,%r13,4), %edx
orl 0x4(%r12), %edx
movq 0x1a8(%rbx), %rcx
movups %xmm0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x5630
xorps %xmm0, %xmm0
incq %r13
cmpq $0x4, %r13
jne 0x9ea1
incq %r14
cmpq $0xf, %r14
jne 0x9e8d
jmp 0x9f31
movq 0x958a(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x1, (%rsp)
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0xc, %r9d
callq 0x5630
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: 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 0x9528(%rip), %rcx      # 0x13470
movq 0x78(%rcx), %rbx
testq %rbx, %rbx
je 0x9fe7
cmpl $0x0, 0x180(%rbx)
jne 0x9f74
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %edx
movl 0x60(%rax,%rdx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9f7d
cmpl $0x0, 0x170(%rbx)
je 0x9f86
movq 0x190(%rbx), %rbx
jmp 0x9f4c
movl 0xd0(%rcx), %eax
movl 0xd4(%rcx), %ecx
cmpl %ecx, %eax
jge 0x9fe7
movl (%rdi), %edx
cmpl %edx, %eax
setl %sil
addl 0x158(%rbx), %eax
cmpl %edx, %eax
setg %dil
testb %dil, %sil
jne 0x9fe9
movq 0x190(%rbx), %rbx
testq %rbx, %rbx
je 0x9fe7
cmpl $0x0, 0x180(%rbx)
jne 0x9fda
movq 0x1a0(%rbx), %rsi
movl 0x58(%rsi), %edi
movl 0x60(%rsi,%rdi,4), %esi
testl %esi, 0x15c(%rbx)
je 0x9faf
cmpl $0x0, 0x170(%rbx)
jne 0x9faf
cmpl %ecx, %eax
jl 0x9f98
popq %rbx
retq
movq %rbx, %rdi
callq 0x9b07
cmpl $0x0, 0x168(%rbx)
je 0xa00d
movq 0x9487(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x945c(%rip), %rdi      # 0x13470
popq %rbx
jmp 0xa3f3
// File: /workspace/github_c_makefile_star2_O3/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 0x944b(%rip), %rdx      # 0x13470
movq 0x78(%rdx), %rdi
testq %rdi, %rdi
je 0xa0c6
cmpl $0x0, 0x180(%rdi)
jne 0xa051
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %esi
movl 0x60(%rcx,%rsi,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0xa05a
cmpl $0x0, 0x170(%rdi)
je 0xa063
movq 0x190(%rdi), %rdi
jmp 0xa029
movl 0xd0(%rdx), %ecx
movl 0xd4(%rdx), %edx
cmpl %edx, %ecx
jge 0xa0c6
movl (%rax), %eax
cmpl %eax, %ecx
setl %sil
addl 0x158(%rdi), %ecx
cmpl %eax, %ecx
setg %r8b
testb %r8b, %sil
jne 0xa0c8
movq 0x190(%rdi), %rdi
testq %rdi, %rdi
je 0xa0c6
cmpl $0x0, 0x180(%rdi)
jne 0xa0b9
movq 0x1a0(%rdi), %rsi
movl 0x58(%rsi), %r8d
movl 0x60(%rsi,%r8,4), %esi
testl %esi, 0x15c(%rdi)
je 0xa08c
cmpl $0x0, 0x170(%rdi)
jne 0xa08c
cmpl %edx, %ecx
jl 0xa075
popq %rax
retq
callq 0x9b07
movq 0x939c(%rip), %rdi      # 0x13470
callq 0xa3f3
popq %rax
jmp 0x8bd7
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x1a0(%rdi)
je 0xa687
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x9d26
movq 0x1a0(%r14), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xa627
leaq 0x190(%rdx), %rcx
cmpq %r14, %rdx
jne 0xa610
movq 0x190(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x9da5
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 0x9b07
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x98a3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: keypress
void
keypress(XEvent *e) {
   unsigned int i;
   KeySym keysym;
   XKeyEvent *ev;

   ev = &e->xkey;
   keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
   for(i = 0; i < LENGTH(keys); i++)
      if(keysym == keys[i].keysym
            && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
            && keys[i].func)
         keys[i].func(&(keys[i].arg));

   if(menu && (cmenu = wintomenu(ev->window)))
   {
      keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
      for(i = 0; i < LENGTH(menu_keys); i++)
         if(keysym == menu_keys[i].keysym
               && CLEANMASK(menu_keys[i].mod) == CLEANMASK(ev->state)
               && menu_keys[i].func)
            menu_keys[i].func(&(menu_keys[i].arg));
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8de7(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5560
movq %rax, %r14
leaq 0x7eb2(%rip), %r15      # 0x12568
movl $0x49, %r12d
cmpq -0x10(%r15), %r14
jne 0xa6e9
movl 0x9150(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa6e9
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa6e9
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
decq %r12
jne 0xa6bc
movq 0x8d87(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xa77c
movq 0x20(%rbx), %rcx
cmpq %rcx, (%rax)
je 0xa71d
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xa702
movq $0x0, 0x9105(%rip) # 0x13820
jmp 0xa77c
movq %rax, 0x90fc(%rip)      # 0x13820
movq 0x8d5d(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5560
movq %rax, %r14
leaq 0x8928(%rip), %r15      # 0x13068
movl $0x6, %r12d
cmpq -0x10(%r15), %r14
jne 0xa773
movl 0x90c6(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa773
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa773
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
decq %r12
jne 0xa746
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x8ac6(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xa9d1
movq 0x20(%rdi), %rcx
cmpq %rcx, (%rax)
je 0xaa13
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xa9c3
movl 0x48(%rdi), %eax
movl 0x4c(%rdi), %esi
movl %eax, %edi
callq 0x76d1
testq %rax, %rax
je 0xaa11
cmpq 0x8a86(%rip), %rax      # 0x13470
je 0xaa11
movq %rax, %rdi
callq 0x9d7c
movq 0x8a6d(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0xaa11
movq %rbx, %rdi
callq 0x77d8
movq 0x90(%rbx), %rbx
jmp 0xa9fb
popq %rbx
retq
movl 0x40(%rdi), %esi
movl 0x44(%rdi), %edx
movq %rax, %rdi
popq %rbx
jmp 0xb5bf
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
cmpl $0x0, 0x38(%rdi)
je 0xaaab
popq %rbx
retq
movq 0x20(%rdi), %rdi
callq 0x6b66
testq %rax, %rax
je 0xaaa9
movq %rax, %rbx
movq %rax, %rdi
callq 0x77d8
cmpl $0x0, 0xb8(%rbx)
je 0xaaa9
popq %rbx
jmp 0x990f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x28(%rdi), %rax
movq 0x8989(%rip), %rcx      # 0x13468
testq %rcx, %rcx
je 0xab1e
movq %rdi, %rbx
movq 0x78(%rcx), %rdi
testq %rdi, %rdi
je 0xab02
cmpq %rax, 0x1a8(%rdi)
je 0xab10
movq 0x190(%rdi), %rdi
jmp 0xaaeb
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0xaae7
jmp 0xab1e
movl $0x1, %esi
callq 0xbd2d
movq 0x28(%rbx), %rax
movq 0x896b(%rip), %rdi      # 0x13490
testq %rdi, %rdi
je 0xab35
cmpq %rax, (%rdi)
je 0xab37
movq 0x10(%rdi), %rdi
jmp 0xab25
popq %rbx
retq
leaq 0x8952(%rip), %rcx      # 0x13490
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xab52
leaq 0x10(%rdx), %rcx
cmpq %rdi, %rdx
jne 0xab3e
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
callq 0x52a0
popq %rbx
jmp 0x990f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x28(%rdi), %rax
movq 0x88f8(%rip), %rcx      # 0x13468
testq %rcx, %rcx
je 0xabac
movq %rdi, %rbx
movq 0x78(%rcx), %rdi
testq %rdi, %rdi
je 0xab93
cmpq %rax, 0x1a8(%rdi)
je 0xaba1
movq 0x190(%rdi), %rdi
jmp 0xab7c
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0xab78
jmp 0xabac
xorl %esi, %esi
callq 0xbd2d
movq 0x28(%rbx), %rax
movq 0x88dd(%rip), %rdi      # 0x13490
testq %rdi, %rdi
je 0xabc3
cmpq %rax, (%rdi)
je 0xabc5
movq 0x10(%rdi), %rdi
jmp 0xabb3
popq %rbx
retq
leaq 0x88c4(%rip), %rcx      # 0x13490
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xabe0
leaq 0x10(%rdx), %rcx
cmpq %rdi, %rdx
jne 0xabcc
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
callq 0x52a0
popq %rbx
jmp 0x990f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x888f(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xac31
cmpq %rsi, (%rax)
je 0xac11
movq 0x10(%rax), %rax
jmp 0xac01
leaq 0x28f1(%rip), %rdx      # 0xd509
movl $0x1, %ecx
movq %rsi, %rdi
xorl %r8d, %r8d
callq 0x859d
callq 0x990f
movq 0x28(%rbx), %rsi
movq 0x8850(%rip), %rdi      # 0x13488
leaq 0x8be9(%rip), %rdx      # 0x13828
callq 0x5640
testl %eax, %eax
je 0xac85
cmpl $0x0, 0x8c51(%rip)      # 0x138a0
jne 0xac85
movq 0x28(%rbx), %rdi
movq 0x880c(%rip), %rax      # 0x13468
testq %rax, %rax
je 0xac87
movq 0x78(%rax), %rcx
testq %rcx, %rcx
je 0xac7c
cmpq %rdi, 0x1a8(%rcx)
je 0xac85
movq 0x190(%rcx), %rcx
jmp 0xac65
movq 0x90(%rax), %rax
jmp 0xac5c
popq %rbx
retq
leaq 0x8b9a(%rip), %rsi      # 0x13828
popq %rbx
jmp 0xbe82
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x28(%rdi), %rax
cmpq 0x89b0(%rip), %rax      # 0x13650
jne 0xad55
movl 0x38(%rdi), %eax
movl %eax, 0x89bd(%rip)      # 0x1366c
movl 0x3c(%rdi), %eax
movl %eax, 0x89b8(%rip)      # 0x13670
callq 0x658a
testl %eax, %eax
je 0xad55
movq 0x8954(%rip), %rsi      # 0x13620
testq %rsi, %rsi
je 0xacdd
movq 0x87b0(%rip), %rdi      # 0x13488
callq 0x5680
movq 0x87a4(%rip), %rdi      # 0x13488
movq 0x8965(%rip), %rsi      # 0x13650
movl 0x897b(%rip), %edx      # 0x1366c
movl 0x897d(%rip), %ecx      # 0x13674
movq 0xe8(%rdi), %rax
movslq 0x8963(%rip), %r8       # 0x13668
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x5700
movq %rax, 0x8906(%rip)      # 0x13620
callq 0x6789
movq 0x8742(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0xad57
movq 0x8756(%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 0x90(%rbx), %rbx
jmp 0xad26
popq %rbx
retq
xorl %edi, %edi
popq %rbx
jmp 0x98a3
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x50e0
cmpl $0x1, 0x28(%rbx)
jne 0xb466
popq %rbx
jmp 0x6a44
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x83b0(%rip), %rdi      # 0x13820
movl 0x38(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x38(%rdi)
testl %eax, %eax
jg 0xb49f
movq 0x30(%rdi), %rax
cmpq $0x0, (%rax)
je 0xb49f
addq $0x20, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpq $0x0, (%rax)
leaq 0x20(%rax), %rax
jne 0xb490
movl %ecx, 0x38(%rdi)
xorl %esi, %esi
xorl %edx, %edx
callq 0xb5bf
movq 0x8371(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xb4cb
callq 0xb468
jmp 0xb4a8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x834b(%rip), %rdi      # 0x13820
movslq 0x38(%rdi), %rax
incq %rax
movq 0x30(%rdi), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
cmpq $0x0, (%rcx,%rdx)
cmovel %esi, %eax
movl %eax, 0x38(%rdi)
xorl %esi, %esi
xorl %edx, %edx
callq 0xb5bf
movq 0x831c(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xb520
callq 0xb4cd
jmp 0xb4fd
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x82f6(%rip), %rax      # 0x13820
movl 0x38(%rax), %ecx
testl %ecx, %ecx
js 0xb598
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xb551
callq 0xb869
movq 0x82da(%rip), %rax      # 0x13820
movq $0x0, 0x28(%rax)
movl 0x38(%rax), %ecx
movq 0x30(%rax), %rdx
movslq %ecx, %rcx
shlq $0x5, %rcx
movq 0x8(%rdx,%rcx), %rdi
testq %rdi, %rdi
je 0xb598
movl 0x10(%rax), %esi
movl 0x3c(%rax), %edx
addl 0x8(%rax), %esi
addl 0xc(%rax), %edx
callq 0xb94f
movq 0x82a2(%rip), %rcx      # 0x13820
movq %rax, 0x28(%rcx)
testq %rax, %rax
je 0xb598
movl $0x0, 0x38(%rax)
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0xb5bf
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xb8e4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7c04(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xb89b
movq %rax, %rcx
cmpq %rbx, 0x28(%rcx)
jne 0xb892
movq $0x0, 0x28(%rcx)
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
jne 0xb884
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0xb8bc
movq %r14, %rdi
callq 0xb869
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0xb8a4
movq 0x7bc4(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xb8e5
leaq 0x7bb8(%rip), %rdi      # 0x13480
movq %rsp, %rsi
movq %rax, %rdx
movq %rdi, %rcx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xb8ee
movq %rsi, %rdi
cmpq %rbx, %rax
jne 0xb8cb
jmp 0xb8ee
retq
leaq 0x7b94(%rip), %rcx      # 0x13480
xorl %edx, %edx
movq %rdx, (%rsp)
movq 0x20(%rbx), %rax
movq (%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x7b84(%rip), %rdi      # 0x13488
movq (%rcx), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x54a0
movq 0x7b6e(%rip), %rdi      # 0x13488
movq 0x18(%rbx), %rsi
callq 0x5680
movq 0x7b5e(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5300
movq %rbx, %rdi
callq 0x52a0
movq 0x7b47(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: 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 %rbx
testq %rdi, %rdi
je 0xbcd7
movq %rdi, %rbx
callq 0xb5bf
movslq 0x38(%rbx), %rax
cmpq $-0x1, %rax
je 0xbcd7
movq 0x30(%rbx), %rdi
shlq $0x5, %rax
movq 0x10(%rdi,%rax), %rcx
testq %rcx, %rcx
je 0xbcd7
addq %rax, %rdi
addq $0x18, %rdi
callq *%rcx
popq %rbx
jmp 0xbcd9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x779c(%rip), %rbx      # 0x13480
testq %rbx, %rbx
je 0xbd25
movq 0x7798(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5300
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rbx
testq %r14, %r14
jne 0xbce9
movq 0x7775(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
movq $0x0, 0x775b(%rip) # 0x13480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x1a0(%rdi), %rbx
movq %rbx, %rdi
callq 0x9d7c
cmpl $0x0, 0x160(%r14)
je 0xbd68
cmpl $0x0, 0x6c(%rbx)
jne 0xbd68
movq %rbx, %rdi
movl $0x1, %esi
callq 0x97e0
movq 0x1a0(%r14), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xbd8a
leaq 0x190(%rdx), %rcx
cmpq %r14, %rdx
jne 0xbd73
movq 0x190(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x9da5
testl %ebp, %ebp
jne 0xbe5d
movl 0x154(%r14), %eax
leaq 0x10(%rsp), %r15
movl %eax, 0x10(%r15)
movq 0x76cd(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0xb8(%rip), %rdi        # 0xbe7f
callq 0x5670
movq 0x76b5(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movl $0x10, %edx
movq %r15, %rcx
callq 0x50d0
movq 0x769a(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5720
movq 0x1a8(%r14), %rsi
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq 0x7670(%rip), %rdi      # 0x13488
movq 0x7691(%rip), %rcx      # 0x134b0
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x5650
addq $0x10, %rsp
movq 0x764a(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x599d(%rip), %rdi     # 0x64af
callq 0x5670
movq 0x7630(%rip), %rdi      # 0x13488
callq 0x5390
movq %r14, %rdi
callq 0x52a0
xorl %edi, %edi
callq 0x9b07
movq %rbx, %rdi
callq 0x98a3
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: systray_add
void
systray_add(Window win) {
   Systray *s;
   char name[256];

   if(!systray_enable)   return;
   if(systray_find(win)) return; /* don't add same window again */

   if(!gettextprop(win, netatom[NetWMName], name, sizeof name))
      gettextprop(win, XA_WM_NAME, name, sizeof name);
   if(name[0] == '\0')
      return;

   s = zcalloc(sizeof(Systray));
   s->win = win;

   s->geo.height = bh;
   s->geo.width  = bh;

   XSelectInput(dpy, s->win, StructureNotifyMask | PropertyChangeMask| EnterWindowMask | FocusChangeMask);
   XReparentWindow(dpy, s->win, traywin, 0, 0);

   // Attach
   if(trayicons) trayicons->prev = s;

   s->next = trayicons;
   trayicons = s;

   return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x6fd0(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xc4d4
cmpq %rbx, (%rax)
je 0xc57a
movq 0x10(%rax), %rax
jmp 0xc4c0
movq 0x6fed(%rip), %rsi      # 0x134c8
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x770a
testl %eax, %eax
jne 0xc504
movq %rsp, %rdx
movl $0x27, %esi
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x770a
cmpb $0x0, (%rsp)
je 0xc57a
movl $0x1, %edi
movl $0x20, %esi
callq 0x55a0
movq %rax, %r14
movq %rbx, (%rax)
movzwl 0x714e(%rip), %eax      # 0x13674
movw %ax, 0xe(%r14)
movw %ax, 0xc(%r14)
movq 0x6f51(%rip), %rdi      # 0x13488
movl $0x620010, %edx         # imm = 0x620010
movq %rbx, %rsi
callq 0x5490
movq 0x6f3d(%rip), %rdi      # 0x13488
movq 0x6f46(%rip), %rdx      # 0x13498
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56e0
movq 0x6f2a(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xc56f
movq %r14, 0x18(%rax)
movq %rax, 0x10(%r14)
movq %r14, 0x6f16(%rip)      # 0x13490
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: updatetitle
void
updatetitle(Client *c) {
   if(!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name))
      gettextprop(c->win, XA_WM_NAME, c->name, sizeof c->name);
   if(c->name[0] == '\0') /* hack to mark broken clients */
      strcpy(c->name, broken);
   c->tw = TEXTW(c->name);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1a8(%rdi), %rdi
movq 0x6f31(%rip), %rsi      # 0x134c8
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x770a
testl %eax, %eax
jne 0xc5c1
movq 0x1a8(%rbx), %rdi
movl $0x27, %esi
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x770a
cmpb $0x0, (%rbx)
jne 0xc5d3
movl $0x6e656b, 0x3(%rbx)    # imm = 0x6E656B
movl $0x6b6f7262, (%rbx)     # imm = 0x6B6F7262
movq %rbx, %rdi
callq 0x52c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x8235
addl 0x704d(%rip), %eax      # 0x13638
movl %eax, 0x158(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: updatesizehints
void
updatesizehints(Client *c) {
   long msize;
   XSizeHints size;

   if(!XGetWMNormalHints(dpy, c->win, &size, &msize))
      /* size is uninitialized, ensure that size.flags aren't used */
      size.flags = PSize;
   if(size.flags & PBaseSize) {
      c->basew = size.base_width;
      c->baseh = size.base_height;
   }
   else if(size.flags & PMinSize) {
      c->basew = size.min_width;
      c->baseh = size.min_height;
   }
   else
      c->basew = c->baseh = 0;
   if(size.flags & PResizeInc) {
      c->incw = size.width_inc;
      c->inch = size.height_inc;
   }
   else
      c->incw = c->inch = 0;
   if(size.flags & PMaxSize) {
      c->maxw = size.max_width;
      c->maxh = size.max_height;
   }
   else
      c->maxw = c->maxh = 0;
   if(size.flags & PMinSize) {
      c->minw = size.min_width;
      c->minh = size.min_height;
   }
   else if(size.flags & PBaseSize) {
      c->minw = size.base_width;
      c->minh = size.base_height;
   }
   else
      c->minw = c->minh = 0;
   if(size.flags & PAspect) {
      c->mina = (float)size.min_aspect.y / size.min_aspect.x;
      c->maxa = (float)size.max_aspect.x / size.max_aspect.y;
   }
   else
      c->maxa = c->mina = 0.0;
   c->isfixed = (c->maxw && c->minw && c->maxh && c->minh
         && c->maxw == c->minw && c->maxh == c->minh);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x6e86(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x5100
testl %eax, %eax
je 0xc63a
movq 0x8(%rsp), %rcx
btl $0x8, %ecx
jb 0xc64f
testb $0x10, %cl
je 0xc63f
movq 0x20(%rsp), %rax
movq %rax, 0x130(%rbx)
jmp 0xc64a
movl $0x8, %ecx
movq $0x0, 0x130(%rbx)
movb $0x1, %sil
jmp 0xc65d
movq 0x48(%rsp), %rax
movq %rax, 0x130(%rbx)
xorl %esi, %esi
xorl %eax, %eax
movl $0x0, %edx
movl $0x0, %edi
testb $0x40, %cl
je 0xc676
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %edi
movl %edx, 0x13c(%rbx)
movl %edi, 0x138(%rbx)
movl $0x0, %edx
testb $0x20, %cl
je 0xc694
movl 0x2c(%rsp), %eax
movl 0x28(%rsp), %edx
movl %eax, 0x144(%rbx)
movl %edx, 0x140(%rbx)
testb $0x10, %cl
jne 0xc6bb
testb %sil, %sil
je 0xc6cb
movq $0x0, 0x148(%rbx)
xorl %esi, %esi
xorl %edi, %edi
jmp 0xc6df
movl 0x20(%rsp), %edi
movl %edi, 0x148(%rbx)
movl 0x24(%rsp), %esi
jmp 0xc6d9
movl 0x48(%rsp), %edi
movl %edi, 0x148(%rbx)
movl 0x4c(%rsp), %esi
movl %esi, 0x14c(%rbx)
xorps %xmm0, %xmm0
testb %cl, %cl
jns 0xc707
movups 0x38(%rsp), %xmm1
movsd 0x3c(%rsp), %xmm0
cvtdq2ps %xmm0, %xmm0
movss 0x44(%rsp), %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[2,3]
cvtdq2ps %xmm2, %xmm1
divps %xmm1, %xmm0
movlps %xmm0, 0x100(%rbx)
testl %edx, %edx
sete %cl
testl %edi, %edi
sete %r8b
orb %cl, %r8b
testl %eax, %eax
sete %r9b
xorl %ecx, %ecx
orb %r8b, %r9b
jne 0xc740
testl %esi, %esi
sete %r8b
cmpl %edi, %edx
setne %dl
orb %r8b, %dl
jne 0xc740
xorl %ecx, %ecx
cmpl %esi, %eax
sete %cl
movl %ecx, 0x164(%rbx)
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: updatewmhints
void
updatewmhints(Client *c) {
   XWMHints *wmh;

   if((wmh = XGetWMHints(dpy, c->win))) {
      if(c == selmon->sel && wmh->flags & XUrgencyHint) {
         wmh->flags &= ~XUrgencyHint;
         XSetWMHints(dpy, c->win, wmh);
      }
      else
         c->isurgent = (wmh->flags & XUrgencyHint) ? True : False;
      XFree(wmh);
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6d2e(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
callq 0x5430
testq %rax, %rax
je 0xc7ac
movq %rax, %rbx
movq 0x6cfb(%rip), %rcx      # 0x13470
movq (%rax), %rax
cmpq %r14, 0x80(%rcx)
jne 0xc7b4
movl %eax, %ecx
andl $0x100, %ecx            # imm = 0x100
je 0xc7b4
andq $-0x101, %rax           # imm = 0xFEFF
movq %rax, (%rbx)
movq 0x6ced(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq %rbx, %rdx
callq 0x5780
jmp 0xc7c1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
shrl $0x8, %eax
andl $0x1, %eax
movl %eax, 0x184(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5070
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: setlayout
void
setlayout(const Arg *arg) {
   if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
      selmon->sellt ^= 1;
   if(arg && arg->v)
      selmon->lt[selmon->sellt] = (Layout *)arg->v;
   strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
   if(selmon->sel)
      arrange(selmon);
   else
      drawbar(selmon);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc7f4
movq (%rdi), %rax
movq 0x6c90(%rip), %rbx      # 0x13470
testq %rax, %rax
je 0xc801
movl 0x5c(%rbx), %ecx
cmpq 0xa0(%rbx,%rcx,8), %rax
jne 0xc804
jmp 0xc812
movq 0x6c75(%rip), %rbx      # 0x13470
xorl $0x1, 0x5c(%rbx)
jmp 0xc823
movl 0x5c(%rbx), %ecx
xorl $0x1, %ecx
movl %ecx, 0x5c(%rbx)
movq (%rdi), %rax
testq %rax, %rax
je 0xc823
movl %ecx, %ecx
movq %rax, 0xa0(%rbx,%rcx,8)
movq 0x6c4d(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x5600
cmpq $0x0, 0x80(%rbx)
je 0xc852
movq %rbx, %rdi
popq %rbx
jmp 0x98a3
movq %rbx, %rdi
popq %rbx
jmp 0x77d8
// File: /workspace/github_c_makefile_star2_O3/Cloudef[P]dwm-fork/dwm.c
// Function: getstate
long
getstate(Window w) {
   int format;
   long result = -1;
   unsigned char *p = NULL;
   unsigned long n, extra;
   Atom real;

   if(XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState],
            &real, &format, &n, &extra, (unsigned char **)&p) != Success)
      return -1;
   if(n != 0)
      result = *p;
   XFree(p);
   return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x6c10(%rip), %rdi      # 0x13488
movq 0x6c31(%rip), %rdx      # 0x134b0
leaq 0x20(%rsp), %r10
movq %rsp, %r11
leaq 0x14(%rsp), %rbx
leaq 0x18(%rsp), %r14
movl $0x2, %r8d
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %rdx
callq 0x5190
addq $0x30, %rsp
movq $-0x1, %rbx
testl %eax, %eax
jne 0xc8cd
cmpq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
je 0xc8c8
movzbl (%rdi), %ebx
callq 0x5070
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/main.c
// Function: jsB_load
static void jsB_load(js_State *J)
{
	int i, n = js_gettop(J);
	for (i = 1; i < n; ++i) {
		js_loadfile(J, js_tostring(J, i));
		js_pushundefined(J);
		js_call(J, 0);
		js_pop(J, 1);
	}
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1530d
cmpl $0x2, %eax
jl 0x3c53
movl %eax, %ebp
movl $0x1, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1448c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17646
movq %rbx, %rdi
callq 0x88f1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16762
movq %rbx, %rdi
movl $0x1, %esi
callq 0x40c7
incl %r14d
cmpl %r14d, %ebp
jne 0x3c16
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x88f1
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/main.c
// Function: jsB_print
static void jsB_print(js_State *J)
{
	int i, top = js_gettop(J);
	for (i = 1; i < top; ++i) {
		const char *s = js_tostring(J, i);
		if (i > 1) putchar(' ');
		fputs(s, stdout);
	}
	putchar('\n');
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1530d
cmpl $0x2, %eax
jl 0x3d05
movl %eax, %ebp
movl $0x1, %r14d
movq 0x3c325(%rip), %r12     # 0x3fff8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1448c
movq %rax, %r15
cmpl $0x2, %r14d
jb 0x3cf1
movl $0x20, %edi
callq 0x3150
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3280
incl %r14d
cmpl %r14d, %ebp
jne 0x3cd3
movl $0xa, %edi
callq 0x3150
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x88f1
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/main.c
// Function: jsB_write
static void jsB_write(js_State *J)
{
	int i, top = js_gettop(J);
	for (i = 1; i < top; ++i) {
		const char *s = js_tostring(J, i);
		if (i > 1) putchar(' ');
		fputs(s, stdout);
	}
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1530d
cmpl $0x2, %eax
jl 0x3d75
movl %eax, %ebp
movl $0x1, %r14d
movq 0x3c2b5(%rip), %r12     # 0x3fff8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1448c
movq %rax, %r15
cmpl $0x2, %r14d
jb 0x3d61
movl $0x20, %edi
callq 0x3150
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3280
incl %r14d
cmpl %r14d, %ebp
jne 0x3d43
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x88f1
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/main.c
// Function: jsB_read
static void jsB_read(js_State *J)
{
	const char *filename = js_tostring(J, 1);
	FILE *f;
	char *s;
	int n, t;

	f = fopen(filename, "rb");
	if (!f) {
		js_error(J, "cannot open file '%s': %s", filename, strerror(errno));
	}

	if (fseek(f, 0, SEEK_END) < 0) {
		fclose(f);
		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
	}

	n = ftell(f);
	if (n < 0) {
		fclose(f);
		js_error(J, "cannot tell in file '%s': %s", filename, strerror(errno));
	}

	if (fseek(f, 0, SEEK_SET) < 0) {
		fclose(f);
		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
	}

	s = malloc(n + 1);
	if (!s) {
		fclose(f);
		js_error(J, "out of memory");
	}

	t = fread(s, 1, n, f);
	if (t != n) {
		free(s);
		fclose(f);
		js_error(J, "cannot read data from file '%s': %s", filename, strerror(errno));
	}
	s[n] = 0;

	js_pushstring(J, s);
	free(s);
	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1448c
movq %rax, %r14
leaq 0x27392(%rip), %rsi     # 0x2b139
movq %rax, %rdi
callq 0x3180
testq %rax, %rax
je 0x3e7d
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3110
testl %eax, %eax
js 0x3e60
movq %r15, %rdi
callq 0x3070
movq %rax, %r12
testl %r12d, %r12d
js 0x3e92
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3110
testl %eax, %eax
js 0x3e60
leal 0x1(%r12), %edi
callq 0x3170
testq %rax, %rax
je 0x3eaf
movq %rax, %r13
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x1, %esi
movq %rax, %rdi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x32c0
cmpl %r12d, %eax
jne 0x3ec8
movb $0x0, (%r13,%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13215
movq %r13, %rdi
callq 0x31e0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x272db(%rip), %rsi     # 0x2b156
jmp 0x3eeb
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x272ac(%rip), %rsi     # 0x2b13c
jmp 0x3eeb
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x272c6(%rip), %rsi     # 0x2b173
jmp 0x3eeb
movq %r15, %rdi
callq 0x3330
leaq 0x272d2(%rip), %rsi     # 0x2b190
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
movq %r13, %rdi
callq 0x31e0
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x272b3(%rip), %rsi     # 0x2b19e
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/main.c
// Function: jsB_readline
static void jsB_readline(js_State *J)
{
	char *line = readline("");
	if (!line) {
		js_pushnull(J);
		return;
	}
	js_pushstring(J, line);
	if (*line)
		add_history(line);
	free(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x304ad(%rip), %rdi     # 0x343b6
callq 0x32e0
testq %rax, %rax
je 0x3f3d
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x13215
cmpb $0x0, (%rbx)
je 0x3f2e
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x130d5
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsarray.c
// Function: js_getlength
int js_getlength(js_State *J, int idx)
{
	int len;
	js_getproperty(J, idx, "length");
	len = js_tointeger(J, -1);
	js_pop(J, 1);
	return len;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1189f
leaq 0x2f805(%rip), %rdx     # 0x33781
movq %rbx, %rdi
movq %rax, %rsi
callq 0x162b5
testl %eax, %eax
jne 0x3f93
movq %rbx, %rdi
callq 0x88f1
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x403b
movl 0x140(%rbx), %edx
movl 0x144(%rbx), %ecx
leal -0x1(%rdx), %esi
movl %esi, 0x140(%rbx)
cmpl %ecx, %edx
jle 0x3fbb
popq %rbx
retq
movl %ecx, 0x140(%rbx)
leaq 0x2f7d6(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pop
void js_pop(js_State *J, int n)
{
	TOP -= n;
	if (TOP < BOT) {
		TOP = BOT;
		js_error(J, "stack underflow!");
	}
}

// Assembly:
movl 0x140(%rdi), %ecx
movl 0x144(%rdi), %eax
subl %esi, %ecx
movl %ecx, 0x140(%rdi)
cmpl %eax, %ecx
jl 0x40e0
retq
pushq %rax
movl %eax, 0x140(%rdi)
leaq 0x2f6b0(%rip), %rsi     # 0x3379e
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pushnumber
void js_pushnumber(js_State *J, double v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TNUMBER;
	STACK[TOP].u.number = v;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x4161
shlq $0x4, %rax
movb $0x4, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movsd %xmm0, (%rax,%rcx)
incl 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x30f52(%rip), %rdx     # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsrun.c
// Function: js_pushobject
void js_pushobject(js_State *J, js_Object *v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TOBJECT;
	STACK[TOP].u.object = v;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x44c3
shlq $0x4, %rax
movb $0x7, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movq %rsi, (%rax,%rcx)
incl 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x30bf0(%rip), %rdx     # 0x350d6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8e1b
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsbuiltin.c
// Function: jsB_propf
void jsB_propf(js_State *J, const char *name, js_CFunction cfun, int n)
{
	const char *pname = strrchr(name, '.');
	pname = pname ? pname + 1 : name;
	js_newcfunction(J, cfun, name, n);
	js_defproperty(J, -2, pname, JS_DONTENUM);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x3240
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r15, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a316
movq %r12, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
movl $0x2, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x662a
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_toString
static void Ap_toString(js_State *J)
{
	if (!js_iscoercible(J, 0))
		js_typeerror(J, "'this' is not an object");
	js_getproperty(J, 0, "join");
	if (!js_iscallable(J, -1)) {
		js_pop(J, 1);
		/* TODO: call Object.prototype.toString implementation directly */
		js_getglobal(J, "Object");
		js_getproperty(J, -1, "prototype");
		js_rot2pop1(J);
		js_getproperty(J, -1, "toString");
		js_rot2pop1(J);
	}
	js_copy(J, 0);
	js_call(J, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x3be91(%rip), %rcx     # 0x403f8
testq %rax, %rax
js 0x4582
cmpl 0x140(%rbx), %eax
jge 0x4582
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rcx
movb 0xf(%rcx), %al
decb %al
cmpb $0x1, %al
jbe 0x4662
leaq 0x2e4e6(%rip), %rdx     # 0x32a7c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fd2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14940
testl %eax, %eax
jne 0x464d
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x4673
leaq 0x2ef94(%rip), %rsi     # 0x3356d
movq %rbx, %rdi
callq 0x15f26
leaq 0x2ebec(%rip), %rdx     # 0x331d4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fd2
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
leaq 0x2e6c4(%rip), %rdx     # 0x32ce2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fd2
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13c1a
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x16762
leaq 0x2f5f0(%rip), %rsi     # 0x33c59
movq %rbx, %rdi
xorl %eax, %eax
callq 0xca10
movl %eax, 0x140(%rbx)
leaq 0x2f11e(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_concat
static void Ap_concat(js_State *J)
{
	int i, top = js_gettop(J);
	int n, k, len;

	js_newarray(J);
	n = 0;

	for (i = 0; i < top; ++i) {
		js_copy(J, i);
		if (js_isarray(J, -1)) {
			len = js_getlength(J, -1);
			for (k = 0; k < len; ++k)
				if (js_hasindex(J, -1, k))
					js_setindex(J, -3, n++);
			js_pop(J, 1);
		} else {
			js_setindex(J, -2, n++);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
callq 0x1318e
testl %r12d, %r12d
jle 0x47bb
xorl %ebp, %ebp
xorl %r14d, %r14d
movl %r12d, 0x4(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13c1a
movslq 0x140(%rbx), %rcx
leaq 0x3bd22(%rip), %rax     # 0x403f8
testq %rcx, %rcx
jle 0x46ed
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
cmpb $0x7, 0xf(%rax)
jne 0x4799
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x4799
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3f6c
testl %eax, %eax
jle 0x4779
movl %eax, %r15d
xorl %r12d, %r12d
movslq 0x140(%rbx), %rax
leaq 0x3bcd0(%rip), %rsi     # 0x403f8
testq %rax, %rax
jle 0x4740
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x14fb2
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x1658a
testl %eax, %eax
je 0x4771
leal 0x1(%r14), %r13d
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r14d, %edx
callq 0x134ed
movl %r13d, %r14d
incl %r12d
cmpl %r12d, %r15d
jne 0x471a
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
movl 0x4(%rsp), %r12d
jg 0x47b0
jmp 0x47ca
leal 0x1(%r14), %r15d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r14d, %edx
callq 0x134ed
movl %r15d, %r14d
incl %ebp
cmpl %r12d, %ebp
jne 0x46be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x2efc7(%rip), %rsi     # 0x3379e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc666
// File: /workspace/github_c_makefile_star2_O3/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_pop
static void Ap_pop(js_State *J)
{
	int n;

	n = js_getlength(J, 0);

	if (n > 0) {
		js_getindex(J, 0, n - 1);
		js_delindex(J, 0, n - 1);
		js_setlength(J, 0, n - 1);
	} else {
		js_setlength(J, 0, 0);
		js_pushundefined(J);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3f6c
testl %eax, %eax
jle 0x4ad8
movl %eax, %ebp
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16538
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16682
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4124
leaq 0x2ecb9(%rip), %rdx     # 0x33781
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4193
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4124
leaq 0x2ec97(%rip), %rdx     # 0x33781
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4193
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x88f1