LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x9e19
leaq 0x198(%rdx), %rcx
cmpq %rdi, %rdx
jne 0x9e02
movq 0x198(%rdi), %rcx
movq %rcx, (%rax)
movq 0x1a0(%rdi), %rax
cmpq %rdi, 0x80(%rax)
je 0x9e34
retq
movq 0x88(%rax), %rcx
testq %rcx, %rcx
je 0x9e71
cmpl $0x0, 0x180(%rcx)
jne 0x9e5f
movq 0x1a0(%rcx), %rdx
movl 0x58(%rdx), %esi
movl 0x60(%rdx,%rsi,4), %edx
testl %edx, 0x15c(%rcx)
je 0x9e68
cmpl $0x0, 0x170(%rcx)
je 0x9e71
movq 0x198(%rcx), %rcx
jmp 0x9e3b
movq %rcx, 0x80(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8681
movabsq $0x200000000, %rax      # imm = 0x200000000
movq %rax, 0x20(%rsp)
movl 0x9972(%rip), %eax      # 0x13818
movl %eax, 0x28(%rsp)
orl $0x2, %eax
movl %eax, 0x2c(%rsp)
movq 0x95d0(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5730
testl %ebp, %ebp
je 0x9f46
xorl %r14d, %r14d
leaq 0x8f97(%rip), %r15      # 0x12e70
xorps %xmm0, %xmm0
movq %r14, %r12
shlq $0x5, %r12
cmpl $0x4, (%r12,%r15)
jne 0x9f3b
addq %r15, %r12
xorl %r13d, %r13d
movq 0x9591(%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 0x5640
xorps %xmm0, %xmm0
incq %r13
cmpq $0x4, %r13
jne 0x9ef0
incq %r14
cmpq $0xf, %r14
jne 0x9edc
jmp 0x9f80
movq 0x953b(%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 0x5640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x94d9(%rip), %rcx      # 0x13470
movq 0x78(%rcx), %rbx
testq %rbx, %rbx
je 0x9fd1
cmpl $0x0, 0x180(%rbx)
jne 0x9fbf
movq 0x1a0(%rbx), %rax
movl 0x58(%rax), %edx
movl 0x60(%rax,%rdx,4), %eax
testl %eax, 0x15c(%rbx)
je 0x9fc8
cmpl $0x0, 0x170(%rbx)
je 0x9fd1
movq 0x190(%rbx), %rbx
jmp 0x9f9b
movl 0xd0(%rcx), %eax
movl 0xd4(%rcx), %ecx
cmpl %ecx, %eax
setge %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0xa044
movl (%rdi), %edx
cmpl %edx, %eax
setl %sil
addl 0x158(%rbx), %eax
cmpl %edx, %eax
setg %dil
testb %dil, %sil
jne 0xa046
movq 0x190(%rbx), %rbx
testq %rbx, %rbx
je 0xa03b
cmpl $0x0, 0x180(%rbx)
jne 0xa032
movq 0x1a0(%rbx), %rsi
movl 0x58(%rsi), %edi
movl 0x60(%rsi,%rdi,4), %esi
testl %esi, 0x15c(%rbx)
je 0xa007
cmpl $0x0, 0x170(%rbx)
jne 0xa007
testq %rbx, %rbx
je 0xa044
cmpl %ecx, %eax
jl 0x9ff0
popq %rbx
retq
movq %rbx, %rdi
callq 0x9b58
cmpl $0x0, 0x168(%rbx)
je 0xa06a
movq 0x942a(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
callq 0x5170
movq 0x93ff(%rip), %rdi      # 0x13470
popq %rbx
jmp 0xa456
// File: /workspace/github_c_makefile_star2_O1/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 0x93ee(%rip), %rdx      # 0x13470
movq 0x78(%rdx), %rdi
testq %rdi, %rdi
je 0xa0bc
cmpl $0x0, 0x180(%rdi)
jne 0xa0aa
movq 0x1a0(%rdi), %rcx
movl 0x58(%rcx), %esi
movl 0x60(%rcx,%rsi,4), %ecx
testl %ecx, 0x15c(%rdi)
je 0xa0b3
cmpl $0x0, 0x170(%rdi)
je 0xa0bc
movq 0x190(%rdi), %rdi
jmp 0xa086
movl 0xd0(%rdx), %ecx
movl 0xd4(%rdx), %edx
cmpl %edx, %ecx
setge %sil
testq %rdi, %rdi
sete %r8b
orb %sil, %r8b
jne 0xa132
movl (%rax), %eax
cmpl %eax, %ecx
setl %sil
addl 0x158(%rdi), %ecx
cmpl %eax, %ecx
setg %r8b
testb %r8b, %sil
jne 0xa134
movq 0x190(%rdi), %rdi
testq %rdi, %rdi
je 0xa129
cmpl $0x0, 0x180(%rdi)
jne 0xa120
movq 0x1a0(%rdi), %rsi
movl 0x58(%rsi), %r8d
movl 0x60(%rsi,%r8,4), %esi
testl %esi, 0x15c(%rdi)
je 0xa0f3
cmpl $0x0, 0x170(%rdi)
jne 0xa0f3
testq %rdi, %rdi
je 0xa132
cmpl %edx, %ecx
jl 0xa0dc
popq %rax
retq
callq 0x9b58
movq 0x9330(%rip), %rdi      # 0x13470
callq 0xa456
popq %rax
jmp 0x8c36
// File: /workspace/github_c_makefile_star2_O1/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 0xa6e6
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x9d77
movq 0x1a0(%r14), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xa686
leaq 0x190(%rdx), %rcx
cmpq %r14, %rdx
jne 0xa66f
movq 0x190(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x9df6
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 0x9b58
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x98ef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8d88(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5570
movq %rax, %r14
leaq 0x7e53(%rip), %r15      # 0x12568
movl $0x49, %r12d
cmpq -0x10(%r15), %r14
jne 0xa748
movl 0x90f1(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa748
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa748
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
decq %r12
jne 0xa71b
movq 0x8d28(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xa7d5
movq 0x20(%rbx), %rcx
cmpq %rcx, (%rax)
je 0xa771
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xa761
xorl %eax, %eax
movq %rax, 0x90a8(%rip)      # 0x13820
testq %rax, %rax
je 0xa7d5
movq 0x8d04(%rip), %rdi      # 0x13488
movzbl 0x54(%rbx), %esi
xorl %edx, %edx
callq 0x5570
movq %rax, %r14
leaq 0x88cf(%rip), %r15      # 0x13068
movl $0x6, %r12d
cmpq -0x10(%r15), %r14
jne 0xa7cc
movl 0x906d(%rip), %eax      # 0x13818
notl %eax
movl 0x50(%rbx), %ecx
xorl -0x18(%r15), %ecx
andl %eax, %ecx
testl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
jne 0xa7cc
movq -0x8(%r15), %rax
testq %rax, %rax
je 0xa7cc
movq %r15, %rdi
callq *%rax
addq $0x20, %r15
decq %r12
jne 0xa79f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8a60(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xaa37
movq 0x20(%rdi), %rcx
cmpq %rcx, (%rax)
je 0xaa39
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xaa29
xorl %eax, %eax
testq %rax, %rax
je 0xaa4d
movl 0x40(%rdi), %esi
movl 0x44(%rdi), %edx
movq %rax, %rdi
popq %rbx
jmp 0xb633
movl 0x48(%rdi), %eax
movl 0x4c(%rdi), %esi
movl %eax, %edi
callq 0x76f8
testq %rax, %rax
je 0xaa8d
cmpq 0x8a0a(%rip), %rax      # 0x13470
je 0xaa8d
movq %rax, %rdi
callq 0x9dcd
movq 0x89f1(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0xaa8d
movq %rbx, %rdi
callq 0x77ff
movq 0x90(%rbx), %rbx
jmp 0xaa77
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab18
popq %rbx
retq
movq 0x20(%rdi), %rdi
callq 0x6c02
testq %rax, %rax
je 0xab16
movq %rax, %rbx
movq %rax, %rdi
callq 0x77ff
cmpl $0x0, 0xb8(%rbx)
je 0xab16
popq %rbx
jmp 0x996a
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x891d(%rip), %rax      # 0x13468
testq %rax, %rax
je 0xab7b
movq 0x28(%rbx), %rcx
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0xab6f
cmpq %rcx, 0x1a8(%rdi)
je 0xab7d
movq 0x190(%rdi), %rdi
jmp 0xab58
movq 0x90(%rax), %rax
testq %rax, %rax
jne 0xab54
xorl %edi, %edi
testq %rdi, %rdi
je 0xab8c
movl $0x1, %esi
callq 0xbddb
movq 0x88fd(%rip), %rdi      # 0x13490
testq %rdi, %rdi
je 0xabaa
movq 0x28(%rbx), %rax
cmpq %rax, (%rdi)
je 0xabac
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0xab9c
xorl %edi, %edi
testq %rdi, %rdi
je 0xabde
leaq 0x88d8(%rip), %rcx      # 0x13490
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xabcc
leaq 0x10(%rdx), %rcx
cmpq %rdi, %rdx
jne 0xabb8
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
callq 0x52a0
popq %rbx
jmp 0x996a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rbx
movq 0x887d(%rip), %rax      # 0x13468
testq %rax, %rax
je 0xac1b
movq 0x28(%rbx), %rcx
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0xac0f
cmpq %rcx, 0x1a8(%rdi)
je 0xac1d
movq 0x190(%rdi), %rdi
jmp 0xabf8
movq 0x90(%rax), %rax
testq %rax, %rax
jne 0xabf4
xorl %edi, %edi
testq %rdi, %rdi
je 0xac29
xorl %esi, %esi
callq 0xbddb
movq 0x8860(%rip), %rdi      # 0x13490
testq %rdi, %rdi
je 0xac47
movq 0x28(%rbx), %rax
cmpq %rax, (%rdi)
je 0xac49
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0xac39
xorl %edi, %edi
testq %rdi, %rdi
je 0xac7b
leaq 0x883b(%rip), %rcx      # 0x13490
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xac69
leaq 0x10(%rdx), %rcx
cmpq %rdi, %rdx
jne 0xac55
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
callq 0x52a0
popq %rbx
jmp 0x996a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8808(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xac9f
movq 0x28(%rbx), %rcx
cmpq %rcx, (%rax)
je 0xaca1
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xac91
xorl %eax, %eax
testq %rax, %rax
je 0xacc5
movq (%rax), %rdi
leaq 0x284c(%rip), %rdx      # 0xd4fc
movl $0x1, %ecx
movq %rdi, %rsi
xorl %r8d, %r8d
callq 0x85ef
callq 0x996a
movq 0x87bc(%rip), %rdi      # 0x13488
movq 0x28(%rbx), %rsi
leaq 0x8b51(%rip), %rdx      # 0x13828
callq 0x5650
testl %eax, %eax
je 0xad1d
cmpl $0x0, 0x8bb9(%rip)      # 0x138a0
jne 0xad1d
movq 0x28(%rbx), %rdi
movq 0x8774(%rip), %rax      # 0x13468
testq %rax, %rax
je 0xad1f
movq 0x78(%rax), %rcx
testq %rcx, %rcx
je 0xad14
cmpq %rdi, 0x1a8(%rcx)
je 0xad1d
movq 0x190(%rcx), %rcx
jmp 0xacfd
movq 0x90(%rax), %rax
jmp 0xacf4
popq %rbx
retq
leaq 0x8b02(%rip), %rsi      # 0x13828
popq %rbx
jmp 0xbf30
// File: /workspace/github_c_makefile_star2_O1/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 0x8918(%rip), %rax      # 0x13650
jne 0xaded
movl 0x38(%rdi), %eax
movl %eax, 0x8925(%rip)      # 0x1366c
movl 0x3c(%rdi), %eax
movl %eax, 0x8920(%rip)      # 0x13670
callq 0x65fd
testl %eax, %eax
je 0xaded
movq 0x88bc(%rip), %rsi      # 0x13620
testq %rsi, %rsi
je 0xad75
movq 0x8718(%rip), %rdi      # 0x13488
callq 0x5690
movq 0x870c(%rip), %rdi      # 0x13488
movq 0x88cd(%rip), %rsi      # 0x13650
movl 0x88e3(%rip), %edx      # 0x1366c
movl 0x88e5(%rip), %ecx      # 0x13674
movq 0xe8(%rdi), %rax
movslq 0x88cb(%rip), %r8       # 0x13668
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x5710
movq %rax, 0x886e(%rip)      # 0x13620
callq 0x6824
movq 0x86aa(%rip), %rbx      # 0x13468
testq %rbx, %rbx
je 0xadef
movq 0x86be(%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 0xadbe
popq %rbx
retq
xorl %edi, %edi
popq %rbx
jmp 0x98ef
// File: /workspace/github_c_makefile_star2_O1/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 0xb4d3
popq %rbx
jmp 0x6adf
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8343(%rip), %rdi      # 0x13820
movl 0x38(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x38(%rdi)
testl %eax, %eax
jg 0xb50c
movq 0x30(%rdi), %rax
cmpq $0x0, (%rax)
je 0xb50c
addq $0x20, %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpq $0x0, (%rax)
leaq 0x20(%rax), %rax
jne 0xb4fd
movl %ecx, 0x38(%rdi)
xorl %esi, %esi
xorl %edx, %edx
callq 0xb633
movq 0x8304(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xb538
callq 0xb4d5
jmp 0xb515
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x82de(%rip), %rdi      # 0x13820
movslq 0x38(%rdi), %rax
incq %rax
movl %eax, 0x38(%rdi)
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 0xb633
movq 0x82ac(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
cmpb $0x0, (%rax)
jne 0xb590
callq 0xb53a
jmp 0xb56d
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8286(%rip), %rax      # 0x13820
cmpl $0x0, 0x38(%rax)
js 0xb60c
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xb5bd
callq 0xb90e
movq 0x826b(%rip), %rax      # 0x13820
movq $0x0, 0x28(%rax)
movq 0x825c(%rip), %rax      # 0x13820
movq 0x30(%rax), %rcx
movslq 0x38(%rax), %rdx
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %rdi
testq %rdi, %rdi
je 0xb60c
movl 0x10(%rax), %esi
movl 0x3c(%rax), %edx
addl 0x8(%rax), %esi
addl 0xc(%rax), %edx
callq 0xb9f4
movq 0x822e(%rip), %rcx      # 0x13820
movq %rax, 0x28(%rcx)
testq %rax, %rax
je 0xb60c
movl $0x0, 0x38(%rax)
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0xb633
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb98b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7b5f(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xb93a
cmpq %rbx, 0x28(%rax)
jne 0xb934
movq $0x0, 0x28(%rax)
movq 0x20(%rax), %rax
jmp 0xb921
movq %rax, (%rsp)
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0xb955
movq %r14, %rdi
callq 0xb90e
movq 0x28(%r14), %r14
jmp 0xb942
movq %r14, (%rsp)
movq 0x7b20(%rip), %rax      # 0x13480
testq %rax, %rax
je 0xb98c
leaq 0x7b14(%rip), %rdi      # 0x13480
movq %rsp, %rdx
movq %rax, %rsi
movq %rsi, %rax
movq %rdi, %rcx
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0xb993
movq %rdx, %rdi
cmpq %rbx, %rsi
jne 0xb972
jmp 0xb993
retq
leaq 0x7aed(%rip), %rcx      # 0x13480
movq %rax, (%rsp)
movq 0x20(%rbx), %rax
movq (%rcx), %rcx
movq %rax, 0x20(%rcx)
movq 0x7adf(%rip), %rdi      # 0x13488
movq (%rcx), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x54a0
movq 0x7ac9(%rip), %rdi      # 0x13488
movq 0x18(%rbx), %rsi
callq 0x5690
movq 0x7ab9(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5300
movq %rbx, %rdi
callq 0x52a0
movq 0x7aa2(%rip), %rdi      # 0x13488
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54c0
// File: /workspace/github_c_makefile_star2_O1/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 0xbd85
movq %rdi, %rbx
callq 0xb633
movslq 0x38(%rbx), %rax
cmpq $-0x1, %rax
je 0xbd85
movq 0x30(%rbx), %rdi
shlq $0x5, %rax
movq 0x10(%rdi,%rax), %rcx
testq %rcx, %rcx
je 0xbd85
addq %rax, %rdi
addq $0x18, %rdi
callq *%rcx
popq %rbx
jmp 0xbd87
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x76ee(%rip), %rbx      # 0x13480
testq %rbx, %rbx
je 0xbdd3
movq 0x76ea(%rip), %rdi      # 0x13488
movq (%rbx), %rsi
callq 0x5300
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rbx
testq %r14, %r14
jne 0xbd97
movq 0x76c7(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
movq $0x0, 0x76ad(%rip) # 0x13480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9dcd
cmpl $0x0, 0x160(%r14)
je 0xbe16
cmpl $0x0, 0x6c(%rbx)
jne 0xbe16
movq %rbx, %rdi
movl $0x1, %esi
callq 0x982c
movq 0x1a0(%r14), %rcx
addq $0x78, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0xbe38
leaq 0x190(%rdx), %rcx
cmpq %r14, %rdx
jne 0xbe21
movq 0x190(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x9df6
testl %ebp, %ebp
jne 0xbf0b
movl 0x154(%r14), %eax
leaq 0x10(%rsp), %r15
movl %eax, 0x10(%r15)
movq 0x761f(%rip), %rdi      # 0x13488
callq 0x50f0
leaq 0xb8(%rip), %rdi        # 0xbf2d
callq 0x5680
movq 0x7607(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movl $0x10, %edx
movq %r15, %rcx
callq 0x50d0
movq 0x75ec(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rcx
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x5730
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq 0x75c9(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq 0x75e3(%rip), %rcx      # 0x134b0
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %rax
callq 0x5660
addq $0x10, %rsp
movq 0x759c(%rip), %rdi      # 0x13488
xorl %esi, %esi
callq 0x54c0
leaq -0x5a04(%rip), %rdi     # 0x64f6
callq 0x5680
movq 0x7582(%rip), %rdi      # 0x13488
callq 0x5390
movq %r14, %rdi
callq 0x52a0
xorl %edi, %edi
callq 0x9b58
movq %rbx, %rdi
callq 0x98ef
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6f1c(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xc588
cmpq %rbx, (%rax)
je 0xc62e
movq 0x10(%rax), %rax
jmp 0xc574
movq 0x6f39(%rip), %rsi      # 0x134c8
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x7731
testl %eax, %eax
jne 0xc5b8
movq %rsp, %rdx
movl $0x27, %esi
movq %rbx, %rdi
movl $0x100, %ecx            # imm = 0x100
callq 0x7731
cmpb $0x0, (%rsp)
je 0xc62e
movl $0x1, %edi
movl $0x20, %esi
callq 0x55b0
movq %rax, %r14
movq %rbx, (%rax)
movzwl 0x709a(%rip), %eax      # 0x13674
movw %ax, 0xe(%r14)
movw %ax, 0xc(%r14)
movq 0x6e9d(%rip), %rdi      # 0x13488
movl $0x620010, %edx         # imm = 0x620010
movq %rbx, %rsi
callq 0x5490
movq 0x6e89(%rip), %rdi      # 0x13488
movq (%r14), %rsi
movq 0x6e8f(%rip), %rdx      # 0x13498
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x56f0
movq 0x6e76(%rip), %rax      # 0x13490
testq %rax, %rax
je 0xc623
movq %r14, 0x18(%rax)
movq %rax, 0x10(%r14)
movq %r14, 0x6e62(%rip)      # 0x13490
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e7d(%rip), %rsi      # 0x134c8
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x7731
testl %eax, %eax
jne 0xc675
movq 0x1a8(%rbx), %rdi
movl $0x27, %esi
movq %rbx, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x7731
cmpb $0x0, (%rbx)
jne 0xc687
movl $0x6e656b, 0x3(%rbx)    # imm = 0x6E656B
movl $0x6b6f7262, (%rbx)     # imm = 0x6B6F7262
movq %rbx, %rdi
callq 0x52c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x8277
addl 0x6f99(%rip), %eax      # 0x13638
movl %eax, 0x158(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6dd2(%rip), %rdi      # 0x13488
movq 0x1a8(%rbx), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x5100
testl %eax, %eax
jne 0xc6d9
movq $0x8, 0x8(%rsp)
movq 0x8(%rsp), %rax
btl $0x8, %eax
jb 0xc6f5
testb $0x10, %al
jne 0xc705
movq $0x0, 0x130(%rbx)
jmp 0xc719
movl 0x48(%rsp), %ecx
movl %ecx, 0x130(%rbx)
movl 0x4c(%rsp), %ecx
jmp 0xc713
movl 0x20(%rsp), %ecx
movl %ecx, 0x130(%rbx)
movl 0x24(%rsp), %ecx
movl %ecx, 0x134(%rbx)
testb $0x40, %al
jne 0xc72a
movq $0x0, 0x138(%rbx)
jmp 0xc73e
movl 0x30(%rsp), %ecx
movl %ecx, 0x138(%rbx)
movl 0x34(%rsp), %ecx
movl %ecx, 0x13c(%rbx)
testb $0x20, %al
jne 0xc74f
movq $0x0, 0x140(%rbx)
jmp 0xc763
movl 0x28(%rsp), %ecx
movl %ecx, 0x140(%rbx)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x144(%rbx)
testb $0x10, %al
jne 0xc77a
btl $0x8, %eax
jb 0xc78a
movq $0x0, 0x148(%rbx)
jmp 0xc79e
movl 0x20(%rsp), %ecx
movl %ecx, 0x148(%rbx)
movl 0x24(%rsp), %ecx
jmp 0xc798
movl 0x48(%rsp), %ecx
movl %ecx, 0x148(%rbx)
movl 0x4c(%rsp), %ecx
movl %ecx, 0x14c(%rbx)
testb %al, %al
js 0xc7b1
movl $0x0, 0x100(%rbx)
xorps %xmm0, %xmm0
jmp 0xc7df
cvtsi2ssl 0x3c(%rsp), %xmm0
cvtsi2ssl 0x38(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x100(%rbx)
xorps %xmm0, %xmm0
cvtsi2ssl 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x44(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x104(%rbx)
movl 0x140(%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0xc824
movl 0x148(%rbx), %edi
testl %edi, %edi
je 0xc824
movl 0x144(%rbx), %edx
testl %edx, %edx
je 0xc824
movl 0x14c(%rbx), %esi
testl %esi, %esi
sete %r8b
cmpl %edi, %ecx
setne %cl
orb %r8b, %cl
jne 0xc824
xorl %eax, %eax
cmpl %esi, %edx
sete %al
movl %eax, 0x164(%rbx)
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6c4a(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
callq 0x5430
testq %rax, %rax
je 0xc889
movq %rax, %rbx
movq 0x6c17(%rip), %rax      # 0x13470
cmpq %r14, 0x80(%rax)
jne 0xc86b
movq (%rbx), %rax
btl $0x8, %eax
jb 0xc891
movl (%rbx), %eax
shrl $0x8, %eax
andl $0x1, %eax
movl %eax, 0x184(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5070
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andq $-0x101, %rax           # imm = 0xFEFF
movq %rax, (%rbx)
movq 0x6be7(%rip), %rdi      # 0x13488
movq 0x1a8(%r14), %rsi
movq %rbx, %rdx
callq 0x5790
jmp 0xc87a
// File: /workspace/github_c_makefile_star2_O1/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 0xc94e
movq (%rdi), %rax
testq %rax, %rax
je 0xc94e
movq 0x6b2f(%rip), %rcx      # 0x13470
movl 0x5c(%rcx), %edx
cmpq 0xa0(%rcx,%rdx,8), %rax
je 0xc959
movq 0x6b1b(%rip), %rax      # 0x13470
xorl $0x1, 0x5c(%rax)
testq %rdi, %rdi
je 0xc978
movq (%rdi), %rax
testq %rax, %rax
je 0xc978
movq 0x6b03(%rip), %rcx      # 0x13470
movl 0x5c(%rcx), %edx
movq %rax, 0xa0(%rcx,%rdx,8)
movq 0x6af1(%rip), %rbx      # 0x13470
movl 0x5c(%rbx), %eax
movq 0xa0(%rbx,%rax,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x5610
cmpq $0x0, 0x80(%rbx)
je 0xc9ae
movq %rbx, %rdi
popq %rbx
jmp 0x98ef
movq %rbx, %rdi
popq %rbx
jmp 0x77ff
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rax
movq $0x0, (%rax)
movq 0x6ab6(%rip), %rdi      # 0x13488
movq 0x6ad7(%rip), %rdx      # 0x134b0
leaq 0x20(%rsp), %r10
leaq 0x8(%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 0xca2d
cmpq $0x0, 0x8(%rsp)
je 0xca24
movq (%rsp), %rax
movzbl (%rax), %ebx
movq (%rsp), %rdi
callq 0x5070
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/grapheMain.c
// Function: main
int main()
{
    // creation du graphe
    // voici les graphes a choisir

    FILE* f = fopen("00014_burma.cha", "r");
    // FILE* f = fopen("05000_USA-road-d-NY.cha", "r");
    // FILE* f = fopen("07397_pla.cha", "r");
    // FILE* f = fopen("test.cha", "r");
    Chaines* c = lectureChaines(f);
    Reseau* r = reconstitueReseauArbre(c);
    Graphe* g = creerGraphe(r);
    fclose(f);
    
    if(reorganiserReseau(r)) {
        printf("ok!\n");
    }

    // liberation de memoire
    liberer_chaines(c);
    liberation_reseau(r);
    liberation_graph(g);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2d99(%rip), %rdi      # 0x4004
leaq 0x2da2(%rip), %rsi      # 0x4014
callq 0x1110
movq %rax, %r12
movq %rax, %rdi
callq 0x1adc
movq %rax, %rbx
movq %rax, %rdi
callq 0x3207
movq %rax, %r14
movq %rax, %rdi
callq 0x12e4
movq %rax, %r15
movq %r12, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x1977
testl %eax, %eax
je 0x12bb
leaq 0x2d60(%rip), %rdi      # 0x4016
callq 0x1070
movq %rbx, %rdi
callq 0x2136
movq %r14, %rdi
callq 0x2941
movq %r15, %rdi
callq 0x1514
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Graphe.c
// Function: libere_liste_aretes
void libere_liste_aretes(Cellule_arete* cell_a){
    // on parcourt cette liste chainee
    // si cette arete est visite pour la premiere fois, on met u a -1
    // pour la deuxieme fois on la libere (cela evitera la double free)
    // cependant, on libere toutes les cellules qu'on vues
    Cellule_arete* tmp = NULL;
    while(cell_a){
        if (cell_a->a->u == -1){
            free(cell_a->a);
        }else{
            cell_a->a->u = -1;
        }
        tmp = cell_a;
        cell_a = cell_a->suiv;
        free(tmp);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1513
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
cmpl $-0x1, (%rdi)
je 0x14f3
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
jmp 0x14f8
callq 0x1030
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x14e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Graphe.c
// Function: liberation_graph
void liberation_graph(Graphe* g){
    // liberation pour les listes de voisins
    for (int i = 0; i < g->nbsom; i++)
    {
        libere_liste_aretes(g->T_som[i]->L_voisin);
        free(g->T_som[i]);
    }

    // liberation de graphe
    free(g->T_commod);
    free(g->T_som);
    free(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x154c
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x18(%rax), %rdi
callq 0x14d7
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1523
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Struct_File.c
// Function: enfile
void enfile(S_file * f, int donnee){
 Cellule_file *nouv=(Cellule_file *) malloc(sizeof(Cellule_file));
  nouv->val=donnee;
  nouv->suiv=NULL;
  if (f->tete==NULL)
    f->tete=nouv;
  else
    f->dernier->suiv=nouv;
  f->dernier=nouv;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x1100
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
movq %rbx, %rcx
je 0x3476
movq 0x8(%rbx), %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Struct_File.c
// Function: defile
int defile(S_file *f){
  int v=f->tete->val;
  Cellule_file *temp=f->tete;
  if (f->tete==f->dernier)
    f->dernier=NULL;
  f->tete=f->tete->suiv;
  free(temp);
  return v;

}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq (%rdi), %rdi
movl (%rdi), %ebx
cmpq 0x8(%rax), %rdi
jne 0x349b
movq $0x0, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
callq 0x1030
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Struct_Liste.c
// Function: ajoute_en_tete
void ajoute_en_tete(ListeEntier* L, int u){
  Cell_entier *nouvsom=(Cell_entier*) malloc(sizeof(Cell_entier));
  nouvsom->u=u;
  nouvsom->suiv=*L;
  *L=nouvsom;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x1100
movl %ebx, (%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Struct_Liste.c
// Function: desalloue
void desalloue(ListeEntier *L){
  Cell_entier *cour,*prec;
  cour=*L;
  while(cour!=NULL){
    prec=cour;
    cour=cour->suiv;
    free(prec);
  }
  *L=NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3539
movq 0x8(%rdi), %r14
callq 0x1030
movq %r14, %rdi
testq %r14, %r14
jne 0x3528
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/trumabrat[P]GrandProjet/Struct_Liste.c
// Function: afficher_liste_entier
void afficher_liste_entier(ListeEntier* L){
  if(!L) printf("L est null!\n");
  ListeEntier tmp = *L;
  printf("[");
  while(tmp){
    printf("%d, ", tmp->u);
    tmp = tmp->suiv;
  }
  printf("]\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3560
leaq 0xf19(%rip), %rdi       # 0x4474
callq 0x1070
movq (%rbx), %r14
movl $0x5b, %edi
callq 0x1040
testq %r14, %r14
je 0x358f
leaq 0xef6(%rip), %rbx       # 0x446f
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10a0
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x3579
leaq 0xeea(%rip), %rdi       # 0x4480
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: createnode
node* createnode(){         //creating a lexer node
    node* mynode = (node*)malloc(sizeof(node));
    mynode->tk = (tokenInfo*)malloc(sizeof(tokenInfo));
    return mynode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x8, %edi
callq 0x2150
movq %rax, %rbx
movl $0x40, %edi
callq 0x2150
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: Keyword_checker
char* Keyword_checker(char val[]){ //check for keywords
    char *s;
    s = (char *) malloc(sizeof(char)*30);
    int i;
    for(i=0;i<30;i++){
        if(strcmp(val,keyword_dict[i])==0){
            strcpy(s,token_key[i]);
            return s;
        }
    }
    char cp[6] = "SORRY";
    strcpy(s,cp);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x1e, %edi
callq 0x2150
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0xad9d(%rip), %r12      # 0xd110
movq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
je 0x23a8
addq $0x8, %r15
cmpq $0xf0, %r15
jne 0x2373
movw $0x59, 0x4(%rbx)
movl $0x52524f53, (%rbx)     # imm = 0x52524F53
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xae51(%rip), %rax      # 0xd200
movq (%r15,%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: remove_comments
int remove_comments(char *B,int forward){   //remove comments from a char array

    while(!((B[forward] == '*') && (B[forward+1] == '*'))){
        forward++;
        if(B[forward] == '\n'){
            lineno++;
        }
    }
    return forward;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xaf0f(%rip), %ecx      # 0xd2f0
movslq %esi, %rdx
movq %rdx, %rax
cmpb $0x2a, (%rdi,%rax)
jne 0x23f4
cmpb $0x2a, 0x1(%rdi,%rax)
je 0x240c
leaq 0x1(%rax), %rdx
cmpb $0xa, 0x1(%rdi,%rax)
movq %rdx, %rax
jne 0x23e7
incl %ecx
movl %ecx, 0xaee6(%rip)      # 0xd2f0
jmp 0x23e4
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: reloadBuff
FILE* reloadBuff(){    //reload the buffer
    fseek( fp1, 0, SEEK_CUR);
    fp1 = getstream(fp1);
    B[3998] = '~';
    return fp1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x174bf(%rip), %rdi     # 0x198d8
xorl %esi, %esi
movl $0x1, %edx
callq 0x2160
movq 0x174ac(%rip), %rdi     # 0x198d8
callq 0x2441
movq %rax, 0x174a0(%rip)     # 0x198d8
movb $0x7e, 0x1843f(%rip)    # 0x1a87e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: getstream
FILE* getstream(FILE *fp){  //the input stream method, reads bufflen data into buffer B and returns file with advanced pointer 
	int i;
    int bufflen = 4000;
    buffer_flush(B);
	if(fp == NULL){
		printf("Invalid File name..\n");
		exit(0);
	}
	//flushing the buffer
    for(i = 0; i < bufflen; i++)
        B[i] = '\0';

	if(fread(B,(size_t)bufflen,1,fp)){
        return fp;
	}
	//printf("(%s)\n",B);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1748e(%rip), %rdi     # 0x198e0
movl $0xfa0, %edx            # imm = 0xFA0
xorl %esi, %esi
callq 0x20f0
testq %rbx, %rbx
je 0x249a
leaq 0x17476(%rip), %r14     # 0x198e0
movl $0xfa0, %edx            # imm = 0xFA0
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2080
testq %rax, %rax
cmovneq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x836c(%rip), %rdi      # 0xa80d
callq 0x2070
xorl %edi, %edi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: removeComments
void removeComments(char *testcaseFile){ //used to remove comments from testcasefile and print clean code in cleanfile

    FILE *f1 = fopen(testcaseFile, "r+");
    if(f1==NULL){
        printf("ERROR OPENING FILE\n");
        return;
    }
    //FILE *f2 = fopen(cleanFile, "w+");
    
    char c;

    while(!feof(f1)){

        c = fgetc(f1);
        if(c=='$')
            break;

        if(c=='*'){
            if(c = fgetc(f1)== '*'){

                while(!((c = fgetc(f1) == '*') && (c = fgetc(f1)== '*')))
                    continue;
                c = fgetc(f1);
                
            }}
 
        fputc(c, stdout);

        }

fclose(f1);
//fclose(f2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x6ee4(%rip), %rsi      # 0x939f
callq 0x2170
testq %rax, %rax
je 0x254b
movq %rax, %rbx
movq %rax, %rdi
callq 0x2140
testl %eax, %eax
jne 0x253f
movq 0xab01(%rip), %r14      # 0xcfe0
movq %rbx, %rdi
callq 0x2100
cmpb $0x2a, %al
je 0x24f5
movzbl %al, %ecx
cmpl $0x24, %ecx
jne 0x2528
jmp 0x253f
movq %rbx, %rdi
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x2a, %ecx
jne 0x2528
movq %rbx, %rdi
callq 0x2100
cmpl $0x2a, %eax
jne 0x2506
movq %rbx, %rdi
callq 0x2100
cmpl $0x2a, %eax
jne 0x2506
movq %rbx, %rdi
callq 0x2100
movsbl %al, %edi
movq (%r14), %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2140
testl %eax, %eax
je 0x24df
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
leaq 0x82cf(%rip), %rdi      # 0xa821
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: size_of
int size_of(int *a){ 
    int i=0;
    int count = 0;
    while(a[i]!=-1){
        i++;
        count++;
    }                       //to compute size of an array, given -1 as end-marker
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, (%rdi)
je 0x30ad
xorl %eax, %eax
cmpl $-0x1, 0x4(%rdi,%rax,4)
leaq 0x1(%rax), %rax
jne 0x30a0
jmp 0x30af
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: presentIn
int presentIn(int *a, int b){

    int i = 0, flag = 0;
    for(i = 0; a[i]!=0; i++){
        if(a[i]==b)
            flag = 1;
    }
    return flag;            //if b is in array a

}

// Assembly:
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x30d7
pushq %rbp
movq %rsp, %rbp
addq $0x4, %rdi
xorl %eax, %eax
movl $0x1, %edx
cmpl %esi, %ecx
cmovel %edx, %eax
movl (%rdi), %ecx
addq $0x4, %rdi
testl %ecx, %ecx
jne 0x30c6
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: epsInFirst
int epsInFirst(int alpha, int first[][11]){         //if epsilon is part of first set
    int i = 0;
    for(i=0; i < 11; i++){
        if(first[alpha][i] == EPLS)
            return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rax
imulq $0x2c, %rax, %rax
addq %rsi, %rax
xorl %ecx, %ecx
cmpl $0x6d, (%rax,%rcx,4)
je 0x3141
incq %rcx
cmpq $0xb, %rcx
jne 0x312e
xorl %eax, %eax
jmp 0x3146
movl $0x1, %eax
popq %rbp
retq