LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x91ab(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5560
movq %rax, %r14
pushq $0x49
popq %r12
leaq 0x8272(%rip), %r15      # 0x12568
subq $0x1, %r12
jb 0xa32f
cmpq -0x10(%r15), %r14
jne 0xa329
movl 0x9510(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa329
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa329
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
jmp 0xa2f6
cmpq $0x0, 0x9149(%rip)      # 0x13480
je 0xa3a7
movq 0x20(%rbx), %rdi
callq 0x58ac
movq %rax, 0x94d7(%rip)      # 0x13820
testq %rax, %rax
je 0xa3a7
movq 0x9133(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5560
movq %rax, %r14
pushq $0x6
popq %r12
leaq 0x8cfa(%rip), %r15      # 0x13068
subq $0x1, %r12
jb 0xa3a7
cmpq -0x10(%r15), %r14
jne 0xa3a1
movl 0x9498(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa3a1
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa3a1
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
jmp 0xa36e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x58ac
testq %rax, %rax
je 0xa5a9
movl 0x40(%rbx), %esi
movl 0x44(%rbx), %edx
movq %rax, %rdi
popq %rbx
jmp 0xb01a
movl 0x48(%rbx), %edi
movl 0x4c(%rbx), %esi
callq 0x7544
testq %rax, %rax
je 0xa5d0
cmpq 0x8eb0(%rip), %rax      # 0x13470
je 0xa5d0
movq %rax, %rdi
callq 0x9a34
popq %rbx
jmp 0x7680
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa641
popq %rbx
retq
movq 0x20(%rdi), %rdi
callq 0x6a20
testq %rax, %rax
je 0xa63f
movq %rax, %rbx
movq %rax, %rdi
callq 0x76a3
cmpl $0x0, 0xb8(%rbx)
je 0xa63f
popq %rbx
jmp 0x960f
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x757f
testq %rax, %rax
je 0xa690
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xb726
movq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0xb822
testq %rax, %rax
je 0xa6b1
movq %rax, %rdi
callq 0xb83d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x960f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x757f
testq %rax, %rax
je 0xa6df
movq %rax, %rdi
xorl %esi, %esi
callq 0xb726
movq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0xb822
testq %rax, %rax
je 0xa700
movq %rax, %rdi
callq 0xb83d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x960f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0xb822
testq %rax, %rax
je 0xa741
movq (%rax), %rdi
leaq 0x2def(%rip), %rdx      # 0xd519
pushq $0x1
popq %rcx
movq %rdi, %rsi
xorl %r8d, %r8d
callq 0x834c
callq 0x960f
movq 0x28(%rbx), %r14
movq 0x8d40(%rip), %rdi      # 0x13488
leaq 0x90d9(%rip), %rdx      # 0x13828
movq %r14, %rsi
callq 0x5640
testl %eax, %eax
je 0xa775
cmpl $0x0, 0x913e(%rip)      # 0x138a0
jne 0xa775
movq 0x28(%rbx), %rbx
movq %rbx, %rdi
callq 0x757f
testq %rax, %rax
je 0xa77d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x90a4(%rip), %rsi      # 0x13828
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb8d3
// File: /workspace/github_c_makefile_star2_O2/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 0x8eb1(%rip), %rax      # 0x13650
jne 0xa857
movl 0x38(%rdi), %eax
movl %eax, 0x8ebe(%rip)      # 0x1366c
movl 0x3c(%rdi), %eax
movl %eax, 0x8eb9(%rip)      # 0x13670
callq 0x6425
testl %eax, %eax
je 0xa857
movq 0x8e55(%rip), %rsi      # 0x13620
testq %rsi, %rsi
je 0xa7dc
movq 0x8cb1(%rip), %rdi      # 0x13488
callq 0x5680
movq 0x8ca5(%rip), %rdi      # 0x13488
movq 0x8e66(%rip), %rsi      # 0x13650
movl 0x8e7c(%rip), %edx      # 0x1366c
movl 0x8e7e(%rip), %ecx      # 0x13674
movq 0xe8(%rdi), %rax
movslq 0x8e64(%rip), %r8       # 0x13668
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x5700
movq %rax, 0x8e07(%rip)      # 0x13620
callq 0x6620
leaq 0x8c43(%rip), %rbx      # 0x13468
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xa859
movq 0x8c54(%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
addq $0x90, %rbx
jmp 0xa825
popq %rbx
retq
xorl %edi, %edi
popq %rbx
jmp 0x958e
// File: /workspace/github_c_makefile_star2_O2/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 0xaed2
popq %rbx
jmp 0x68fb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8944(%rip), %rdi      # 0x13820
movl 0x38(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x38(%rdi)
testl %eax, %eax
jle 0xaf17
xorl %esi, %esi
xorl %edx, %edx
callq 0xb01a
movq 0x8927(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xaf15
callq 0xaed4
jmp 0xaef2
popq %rax
retq
movq 0x30(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax)
je 0xaee9
movl %ecx, 0x38(%rdi)
incl %ecx
addq $0x20, %rax
jmp 0xaf1d
// File: /workspace/github_c_makefile_star2_O2/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 0x88ea(%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 0xb01a
movq 0x88bb(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xaf81
callq 0xaf2e
jmp 0xaf5e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8895(%rip), %rax      # 0x13820
movl 0x38(%rax), %ecx
testl %ecx, %ecx
js 0xaff3
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xafaf
callq 0xb2a0
movq 0x8879(%rip), %rax      # 0x13820
andq $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 0xaff3
movl 0x10(%rax), %esi
movl 0x3c(%rax), %edx
addl 0x8(%rax), %esi
addl 0xc(%rax), %edx
callq 0xb373
movq 0x8844(%rip), %rcx      # 0x13820
movq %rax, 0x28(%rcx)
testq %rax, %rax
je 0xaff3
andl $0x0, 0x38(%rax)
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0xb01a
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb372
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x81c9(%rip), %rax      # 0x13480
movq (%rax), %rax
testq %rax, %rax
je 0xb2d0
cmpq %rbx, 0x28(%rax)
jne 0xb2ca
andq $0x0, 0x28(%rax)
addq $0x20, %rax
jmp 0xb2b7
movq %rbx, %r14
movq 0x28(%r14), %r14
testq %r14, %r14
je 0xb2e6
movq %r14, %rdi
callq 0xb2a0
jmp 0xb2d3
leaq 0x8193(%rip), %rdi      # 0x13480
movq 0x818c(%rip), %rsi      # 0x13480
movq %rsp, %rax
movq %rdi, %rcx
movq %rsi, %rdx
testq %rsi, %rsi
je 0xb313
movq 0x20(%rdx), %rsi
testq %rsi, %rsi
je 0xb313
movq %rax, %rdi
cmpq %rbx, %rsi
jne 0xb2f7
movq %rdx, (%rsp)
movq 0x20(%rbx), %rax
movq (%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x815f(%rip), %rdi      # 0x13488
movq (%rcx), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x54a0
movq 0x814b(%rip), %rdi      # 0x13488
movq 0x18(%rbx), %rsi
callq 0x5680
movq 0x813b(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5300
movq %rbx, %rdi
callq 0x52a0
movq 0x8124(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb6d8
movq %rdi, %rbx
callq 0xb01a
movslq 0x38(%rbx), %rax
cmpq $-0x1, %rax
je 0xb6d8
movq 0x30(%rbx), %rdi
shlq $0x5, %rax
movq 0x10(%rdi,%rax), %rcx
testq %rcx, %rcx
je 0xb6d8
addq %rax, %rdi
addq $0x18, %rdi
callq *%rcx
popq %rbx
jmp 0xb6da
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7d9b(%rip), %rbx      # 0x13480
testq %rbx, %rbx
je 0xb71e
movq 0x7d97(%rip), %rdi      # 0x13488
testq %rbx, %rbx
je 0xb70f
movq (%rbx), %rsi
callq 0x5300
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rbx
jmp 0xb6ea
xorl %esi, %esi
callq 0x54c0
andq $0x0, 0x7d62(%rip)      # 0x13480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x1a0(%rdi), %rbx
movq %rbx, %rdi
callq 0x9a34
cmpl $0x0, 0x160(%r14)
je 0xb75f
cmpl $0x0, 0x6c(%rbx)
jne 0xb75f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x94d2
movq %r14, %rdi
callq 0xb864
movq %r14, %rdi
callq 0x9a5b
testl %ebp, %ebp
jne 0xb800
movl 0x154(%r14), %eax
movq %rsp, %r15
movl %eax, 0x10(%r15)
movq 0x7cfc(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0xf9(%rip), %rdi        # 0xb891
callq 0x5670
movq 0x7ce4(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rcx
callq 0x50d0
movq 0x7ccb(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5720
movq %r14, %rdi
xorl %esi, %esi
callq 0xb894
movq 0x7ca7(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x549e(%rip), %rdi     # 0x6351
callq 0x5670
movq 0x7c8d(%rip), %rdi      # 0x13488
callq 0x5390
movq %r14, %rdi
callq 0x52a0
xorl %edi, %edi
callq 0x97fb
movq %rbx, %rdi
callq 0x958e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: systray_del
void
systray_del(Systray *s) {
   Systray **ss;

   if(!systray_enable) return;

   for(ss = &trayicons; *ss && *ss != s; ss = &(*ss)->next);
   *ss = s->next;

   IFREE(s);
}

// Assembly:
leaq 0x7c4c(%rip), %rcx      # 0x13490
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xb858
leaq 0x10(%rdx), %rcx
cmpq %rdi, %rdx
jne 0xb844
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
jmp 0x52a0
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xb822
testq %rax, %rax
jne 0xbf30
movq 0x7631(%rip), %rsi      # 0x134c8
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x75b7
testl %eax, %eax
jne 0xbebe
pushq $0x27
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x75b7
cmpb $0x0, (%rsp)
je 0xbf30
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x55a0
movq %rax, %r14
movq %rbx, (%rax)
movzwl 0x7798(%rip), %eax      # 0x13674
movw %ax, 0xe(%r14)
movw %ax, 0xc(%r14)
movq 0x759b(%rip), %rdi      # 0x13488
movl $0x620010, %edx         # imm = 0x620010
movq %rbx, %rsi
callq 0x5490
movq 0x7587(%rip), %rdi      # 0x13488
movq 0x7590(%rip), %rdx      # 0x13498
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56e0
movq 0x7574(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xbf25
movq %r14, 0x18(%rax)
movq %rax, 0x10(%r14)
movq %r14, 0x7560(%rip)      # 0x13490
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x757b(%rip), %rsi      # 0x134c8
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x75b7
testl %eax, %eax
jne 0xbf75
movq 0x1a8(%rbx), %rdi
pushq $0x27
popq %rsi
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x75b7
cmpb $0x0, (%rbx)
jne 0xbf87
movl $0x6e656b, 0x3(%rbx)    # imm = 0x6E656B
movl $0x6b6f7262, (%rbx)     # imm = 0x6B6F7262
movq %rbx, %rdi
callq 0x52c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x8039
addl 0x7699(%rip), %eax      # 0x13638
movl %eax, 0x158(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x74d2(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x5100
testl %eax, %eax
je 0xbfee
movq 0x8(%rsp), %rcx
btl $0x8, %ecx
jb 0xbffe
testb $0x10, %cl
je 0xbff1
movq 0x20(%rsp), %rax
movq %rax, 0x130(%rbx)
jmp 0xbff9
pushq $0x8
popq %rcx
andq $0x0, 0x130(%rbx)
movb $0x1, %sil
jmp 0xc00c
movq 0x48(%rsp), %rax
movq %rax, 0x130(%rbx)
xorl %esi, %esi
xorl %eax, %eax
movl $0x0, %edx
movl $0x0, %edi
testb $0x40, %cl
je 0xc025
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %edi
movl %edx, 0x13c(%rbx)
movl %edi, 0x138(%rbx)
movl $0x0, %edx
testb $0x20, %cl
je 0xc043
movl 0x2c(%rsp), %eax
movl 0x28(%rsp), %edx
movl %eax, 0x144(%rbx)
movl %edx, 0x140(%rbx)
testb $0x10, %cl
jne 0xc067
testb %sil, %sil
je 0xc077
andq $0x0, 0x148(%rbx)
xorl %esi, %esi
xorl %edi, %edi
jmp 0xc08b
movl 0x20(%rsp), %edi
movl %edi, 0x148(%rbx)
movl 0x24(%rsp), %esi
jmp 0xc085
movl 0x48(%rsp), %edi
movl %edi, 0x148(%rbx)
movl 0x4c(%rsp), %esi
movl %esi, 0x14c(%rbx)
xorps %xmm0, %xmm0
testb %cl, %cl
jns 0xc0b3
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 0xc0ec
testl %esi, %esi
sete %r8b
cmpl %edi, %edx
setne %dl
orb %r8b, %dl
jne 0xc0ec
xorl %ecx, %ecx
cmpl %esi, %eax
sete %cl
movl %ecx, 0x164(%rbx)
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7382(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
callq 0x5430
testq %rax, %rax
je 0xc158
movq %rax, %rbx
movq 0x734f(%rip), %rcx      # 0x13470
movq (%rax), %rax
cmpq %r14, 0x80(%rcx)
jne 0xc160
movl %eax, %ecx
andl $0x100, %ecx            # imm = 0x100
je 0xc160
andq $-0x101, %rax           # imm = 0xFEFF
movq %rax, (%rbx)
movq 0x7341(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq %rbx, %rdx
callq 0x5780
jmp 0xc16d
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_O2/Cloudef[P]dwm-fork/dwm.c
// Function: dirtomon
Monitor *
dirtomon(int dir) {
   Monitor *m = NULL;

   if(dir > 0) {
      if(!(m = selmon->next))
         m = mons;
   }
   else {
      if(selmon == mons)
         for(m = mons; m->next; m = m->next);
      else
         for(m = mons; m->next != selmon; m = m->next);
   }
   return m;
}

// Assembly:
movq 0x72ed(%rip), %rdx      # 0x13470
testl %edi, %edi
jle 0xc19b
movq 0x90(%rdx), %rax
testq %rax, %rax
jne 0xc1c7
movq 0x72ce(%rip), %rax      # 0x13468
retq
movq 0x72c6(%rip), %rcx      # 0x13468
cmpq %rcx, %rdx
je 0xc1b8
movq %rcx, %rax
movq 0x90(%rcx), %rcx
cmpq %rdx, %rcx
jne 0xc1a7
jmp 0xc1c7
movq %rcx, %rax
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0xc1b8
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc1ec
movq (%rdi), %rax
movq 0x7298(%rip), %rbx      # 0x13470
testq %rax, %rax
je 0xc1f9
movl 0x5c(%rbx), %ecx
cmpq 0xa0(%rbx,%rcx,8), %rax
jne 0xc1fc
jmp 0xc20a
movq 0x727d(%rip), %rbx      # 0x13470
xorl $0x1, 0x5c(%rbx)
jmp 0xc21b
movl 0x5c(%rbx), %ecx
xorl $0x1, %ecx
movl %ecx, 0x5c(%rbx)
movq (%rdi), %rax
testq %rax, %rax
je 0xc21b
movl %ecx, %ecx
movq %rax, 0xa0(%rbx,%rcx,8)
movq 0x7255(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x5600
cmpq $0x0, 0x80(%rbx)
je 0xc248
movq %rbx, %rdi
popq %rbx
jmp 0x958e
movq %rbx, %rdi
popq %rbx
jmp 0x76a3
// File: /workspace/github_c_makefile_star2_O2/Cloudef[P]dwm-fork/dwm.c
// Function: 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
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
movq %rdi, %rsi
movq 0x721d(%rip), %rdi      # 0x13488
movq 0x723e(%rip), %rdx      # 0x134b0
leaq 0x20(%rsp), %r10
movq %rsp, %r11
leaq 0x14(%rsp), %rbx
leaq 0x18(%rsp), %r14
pushq $0x2
popq %r8
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq %rdx
callq 0x5190
addq $0x30, %rsp
testl %eax, %eax
je 0xc2a8
pushq $-0x1
popq %rbx
jmp 0xc2c1
cmpq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
je 0xc2b9
movzbl (%rdi), %ebx
jmp 0xc2bc
pushq $-0x1
popq %rbx
callq 0x5070
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xff5f
movl %eax, %ebp
pushq $0x1
popq %r14
movl %r14d, %r15d
cmpl %ebp, %r15d
jge 0x3bb2
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf64d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11c6a
movq %rbx, %rdi
callq 0x7336
movq %rbx, %rdi
xorl %esi, %esi
callq 0x110b0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3f3d
incl %r15d
jmp 0x3b75
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xff5f
movl %eax, %ebp
pushq $0x1
popq %r14
pushq $0x20
popq %r15
movq 0x333c6(%rip), %r13     # 0x36ff8
cmpl %ebp, %r14d
jge 0x3c64
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf64d
movq %rax, %r12
cmpl $0x2, %r14d
jb 0x3c53
movl %r15d, %edi
callq 0x3150
movq (%r13), %rsi
movq %r12, %rdi
callq 0x3280
incl %r14d
jmp 0x3c32
pushq $0xa
popq %rdi
callq 0x3150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xff5f
movl %eax, %ebp
pushq $0x1
popq %r14
pushq $0x20
popq %r15
movq 0x33352(%rip), %r13     # 0x36ff8
cmpl %ebp, %r14d
jge 0x3cd8
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf64d
movq %rax, %r12
cmpl $0x2, %r14d
jb 0x3cc7
movl %r15d, %edi
callq 0x3150
movq (%r13), %rsi
movq %r12, %rdi
callq 0x3280
incl %r14d
jmp 0x3ca6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0xf64d
movq %rax, %r14
leaq 0x1c42b(%rip), %rsi     # 0x20139
movq %rax, %rdi
callq 0x3180
testq %rax, %rax
je 0x3de0
movq %rax, %r15
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x3110
testl %eax, %eax
js 0x3dc3
movq %r15, %rdi
callq 0x3070
movq %rax, %r12
testl %r12d, %r12d
js 0x3df5
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3110
testl %eax, %eax
js 0x3dc3
leal 0x1(%r12), %edi
callq 0x3170
testq %rax, %rax
je 0x3e12
movq %rax, %r13
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x32c0
cmpl %r12d, %eax
jne 0x3e2b
movb $0x0, (%r13,%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xe7f7
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 0x1c378(%rip), %rsi     # 0x20156
jmp 0x3e4e
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x1c349(%rip), %rsi     # 0x2013c
jmp 0x3e4e
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x1c363(%rip), %rsi     # 0x20173
jmp 0x3e4e
movq %r15, %rdi
callq 0x3330
leaq 0x1c36f(%rip), %rsi     # 0x20190
movq %rbx, %rdi
xorl %eax, %eax
callq 0x95fc
movq %r13, %rdi
callq 0x31e0
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x1c350(%rip), %rsi     # 0x2019e
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/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 0x25525(%rip), %rdi     # 0x29391
callq 0x32e0
testq %rax, %rax
je 0x3ea0
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe7f7
cmpb $0x0, (%rbx)
je 0x3e91
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 0xe756
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24878(%rip), %rdx     # 0x28751
callq 0x3eff
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f23
movl %eax, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3f56
retq
pushq %rax
movl %eax, 0x140(%rdi)
leaq 0x2480a(%rip), %rsi     # 0x2876e
xorl %eax, %eax
callq 0x95fc
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x3fd7
movq 0x148(%rdi), %rcx
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
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x42b0
movq 0x148(%rdi), %rcx
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
callq 0xf77a
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2e
popq %rsi
movq %r15, %rdi
callq 0x3240
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r15, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x5958
pushq $-0x2
popq %rsi
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r13, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5963
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xf93a
testl %eax, %eax
je 0x43e0
leaq 0x23726(%rip), %rdx     # 0x27a4c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3eff
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0xf950
testl %eax, %eax
jne 0x43c6
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f3d
leaq 0x241e8(%rip), %rsi     # 0x2853d
movq %rbx, %rdi
callq 0x10930
leaq 0x23e40(%rip), %rdx     # 0x281a4
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3eff
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 0x23918(%rip), %rdx     # 0x27cb2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3eff
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 0xeee2
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x110b0
leaq 0x24842(%rip), %rsi     # 0x28c29
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/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), %ebp
subl 0x144(%rdi), %ebp
callq 0xe7d1
xorl %r12d, %r12d
testl %ebp, %ebp
cmovlel %r12d, %ebp
movl %ebp, (%rsp)
pushq $-0x1
popq %rbp
xorl %r15d, %r15d
cmpl (%rsp), %r15d
je 0x44be
movq %rbx, %rdi
movl %r15d, %esi
callq 0xeee2
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf97f
testl %eax, %eax
je 0x44a0
movl %r15d, 0x4(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ecc
movl %eax, %r15d
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %r15d
movq %rbx, %rdi
cmpl %r14d, %r15d
je 0x4491
movl %ebp, %esi
movl %r14d, %edx
callq 0x10ecd
testl %eax, %eax
je 0x448c
leal 0x1(%r12), %r13d
movq %rbx, %rdi
pushq $-0x3
popq %rsi
movl %r12d, %edx
callq 0xe9c5
movl %r13d, %r12d
incl %r14d
jmp 0x4460
pushq $0x1
popq %rsi
callq 0x3f3d
movl 0x4(%rsp), %r15d
jmp 0x44b6
leal 0x1(%r12), %r14d
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movl %r12d, %edx
callq 0xe9c5
movl %r14d, %r12d
incl %r15d
jmp 0x4422
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ecc
testl %eax, %eax
jle 0x4731
movl %eax, %ebp
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10e96
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10fd5
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f6b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3f6b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_push
static void Ap_push(js_State *J)
{
	int i, top = js_gettop(J);
	int n;

	n = js_getlength(J, 0);

	for (i = 1; i < top; ++i, ++n) {
		js_copy(J, i);
		js_setindex(J, 0, n);
	}

	js_setlength(J, 0, n);

	js_pushnumber(J, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
xorl %esi, %esi
callq 0x3ecc
movl %eax, %r14d
pushq $0x1
popq %r15
cmpl %r12d, %r15d
jge 0x4799
leal (%r14,%r15), %ebp
decl %ebp
movq %rbx, %rdi
movl %r15d, %esi
callq 0xeee2
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xe9c5
incl %r15d
jmp 0x4772
leal (%r14,%r15), %ebp
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x3f6b
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f9a
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_reverse
static void Ap_reverse(js_State *J)
{
	int len, middle, lower;

	len = js_getlength(J, 0);
	middle = len / 2;
	lower = 0;

	while (lower != middle) {
		int upper = len - lower - 1;
		int haslower = js_hasindex(J, 0, lower);
		int hasupper = js_hasindex(J, 0, upper);
		if (haslower && hasupper) {
			js_setindex(J, 0, lower);
			js_setindex(J, 0, upper);
		} else if (hasupper) {
			js_setindex(J, 0, lower);
			js_delindex(J, 0, upper);
		} else if (haslower) {
			js_setindex(J, 0, upper);
			js_delindex(J, 0, lower);
		}
		++lower;
	}

	js_copy(J, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x3ecc
movl %eax, %r14d
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %r15d
decl %r14d
cmpl %ebp, %r15d
je 0x4873
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10ecd
movl %eax, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x10ecd
testl %r12d, %r12d
setne %cl
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4834
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xe9c5
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0xe9c5
jmp 0x486c
testl %eax, %eax
je 0x484e
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xe9c5
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
jmp 0x4867
testl %r12d, %r12d
je 0x486c
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0xe9c5
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10fd5
incl %ebp
jmp 0x47df
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xeee2
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_shift
static void Ap_shift(js_State *J)
{
	int k, len;

	len = js_getlength(J, 0);

	if (len == 0) {
		js_setlength(J, 0, 0);
		js_pushundefined(J);
		return;
	}

	js_getindex(J, 0, 0);

	for (k = 1; k < len; ++k) {
		if (js_hasindex(J, 0, k))
			js_setindex(J, 0, k - 1);
		else
			js_delindex(J, 0, k - 1);
	}

	js_delindex(J, 0, len - 1);
	js_setlength(J, 0, len - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x3ecc
testl %eax, %eax
je 0x4902
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10e96
leal 0x1(%r14), %r15d
cmpl %ebp, %r15d
jge 0x48de
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x10ecd
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
testl %eax, %eax
je 0x48d4
callq 0xe9c5
jmp 0x48d9
callq 0x10fd5
movl %r15d, %r14d
jmp 0x48ab
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x10fd5
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f6b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3f6b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7336
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_slice
static void Ap_slice(js_State *J)
{
	int len, s, e, n;
	double sv, ev;

	js_newarray(J);

	len = js_getlength(J, 0);
	sv = js_tointeger(J, 1);
	ev = js_isdefined(J, 2) ? js_tointeger(J, 2) : len;

	if (sv < 0) sv = sv + len;
	if (ev < 0) ev = ev + len;

	s = sv < 0 ? 0 : sv > len ? len : sv;
	e = ev < 0 ? 0 : ev > len ? len : ev;

	for (n = 0; s < e; ++s, ++n)
		if (js_hasindex(J, 0, s))
			js_setindex(J, -2, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xe7d1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3ecc
movl %eax, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3f23
movl %eax, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xf8a8
testl %eax, %eax
je 0x4966
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3f23
jmp 0x4968
movl %ebp, %eax
cvtsi2sd %r14d, %xmm2
cvtsi2sd %ebp, %xmm0
movsd 0x1ba87(%rip), %xmm3    # 0x20400
movapd %xmm0, %xmm1
testl %r14d, %r14d
js 0x4986
movapd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvtsi2sd %eax, %xmm4
movapd %xmm0, %xmm2
testl %eax, %eax
js 0x499a
movapd %xmm3, %xmm2
addsd %xmm4, %xmm2
xorl %r15d, %r15d
xorpd %xmm3, %xmm3
ucomisd %xmm1, %xmm3
movl $0x0, %r12d
ja 0x49be
movapd %xmm0, %xmm4
minsd %xmm1, %xmm4
cvttsd2si %xmm4, %r12d
ucomisd %xmm2, %xmm3
ja 0x49cd
minsd %xmm2, %xmm0
cvttsd2si %xmm0, %r15d
xorl %r14d, %r14d
pushq $-0x2
popq %rbp
leal (%r12,%r14), %edx
cmpl %r15d, %edx
jge 0x49fc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10ecd
testl %eax, %eax
je 0x49f7
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0xe9c5
incl %r14d
jmp 0x49d3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_sort
static void Ap_sort(js_State *J)
{
	int len;

	len = js_getlength(J, 0);
	if (len <= 1) {
		js_copy(J, 0);
		return;
	}

	if (!js_iscallable(J, 1) && !js_isundefined(J, 1))
		js_typeerror(J, "comparison function must be a function or undefined");

	if (len >= INT_MAX)
		js_rangeerror(J, "array is too large to sort");

	Ap_sort_heapsort(J, len);

	js_copy(J, 0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3ecc
cmpl $0x2, %eax
jl 0x4a7c
movl %eax, %ebp
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf950
testl %eax, %eax
jne 0x4a38
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf8bb
testl %eax, %eax
je 0x4a9b
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
je 0x4a8a
movl %ebp, %r14d
shrl %r14d
testl %r14d, %r14d
jle 0x4a77
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x15470
jmp 0x4a46
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x154fb
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x15470
cmpl $0x2, %ebp
jge 0x4a5d
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xeee2
leaq 0x241e6(%rip), %rsi     # 0x28c77
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9778
leaq 0x241a1(%rip), %rsi     # 0x28c43
movq %rbx, %rdi
xorl %eax, %eax
callq 0x99a6
// File: /workspace/github_c_makefile_star2_O2/ArtifexSoftware[P]mujs/./jsarray.c
// Function: Ap_unshift
static void Ap_unshift(js_State *J)
{
	int i, top = js_gettop(J);
	int k, len;

	len = js_getlength(J, 0);

	for (k = len; k > 0; --k) {
		int from = k - 1;
		int to = k + top - 2;
		if (js_hasindex(J, 0, from))
			js_setindex(J, 0, to);
		else
			js_delindex(J, 0, to);
	}

	for (i = 1; i < top; ++i) {
		js_copy(J, i);
		js_setindex(J, 0, i - 1);
	}

	js_setlength(J, 0, len + top - 1);

	js_pushnumber(J, len + top - 1);
}

// 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
xorl %esi, %esi
callq 0x3ecc
movl %eax, %r14d
leal -0x2(%r12), %r13d
movl %eax, %r15d
testl %r15d, %r15d
jle 0x4cfd
leal (%r15,%r13), %ebp
decl %r15d
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x10ecd
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
testl %eax, %eax
je 0x4cf6
callq 0xe9c5
jmp 0x4ccb
callq 0x10fd5
jmp 0x4ccb
pushq $0x1
popq %r15
cmpl %r12d, %r15d
jge 0x4d24
movq %rbx, %rdi
movl %r15d, %esi
callq 0xeee2
leal -0x1(%r15), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe9c5
incl %r15d
jmp 0x4d01
leal (%r12,%r14), %ebp
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x3f6b
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3f9a