LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x8d7d(%rip), %rax      # 0x18620
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0xf8c7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xf8d0
jmp 0xf8e3
jmp 0xf8d2
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xf8a7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0xf902
movq -0x8(%rbp), %rdi
callq 0x52b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf840
cmpq $0x0, %rax
je 0x10173
jmp 0x1026a
movq -0x8(%rbp), %rdi
movq 0x84da(%rip), %rsi      # 0x18658
leaq -0x110(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x89c0
cmpl $0x0, %eax
jne 0x101ae
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movl $0x27, %esi
movl $0x100, %ecx            # imm = 0x100
callq 0x89c0
movsbl -0x110(%rbp), %eax
cmpl $0x0, %eax
jne 0x101bf
jmp 0x1026a
movl $0x1, %edi
movl $0x20, %esi
callq 0x55c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl 0x8621(%rip), %eax      # 0x18804
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xe(%rax)
movl 0x8610(%rip), %eax      # 0x18804
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movq 0x8412(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x620010, %edx         # imm = 0x620010
callq 0x54a0
movq 0x83fa(%rip), %rdi      # 0x18618
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x83fc(%rip), %rdx      # 0x18628
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x56f0
cmpq $0x0, 0x83e1(%rip)      # 0x18620
je 0x10250
movq -0x10(%rbp), %rcx
movq 0x83d4(%rip), %rax      # 0x18620
movq %rcx, 0x18(%rax)
movq 0x83c9(%rip), %rcx      # 0x18620
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x83b6(%rip)      # 0x18620
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
movq 0x83ba(%rip), %rsi      # 0x18658
movq -0x8(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x89c0
cmpl $0x0, %eax
jne 0x102cf
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rdi
movq -0x8(%rbp), %rdx
movl $0x27, %esi
movl $0x100, %ecx            # imm = 0x100
callq 0x89c0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x102eb
movq -0x8(%rbp), %rdi
leaq 0x1f3a(%rip), %rsi      # 0x12220
callq 0x5560
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52d0
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x9690
movl %eax, %ecx
addl 0x84b9(%rip), %ecx      # 0x187c8
movq -0x8(%rbp), %rax
movl %ecx, 0x158(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7d15(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
callq 0x5440
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x109a5
movq -0x8(%rbp), %rax
movq 0x7cd4(%rip), %rcx      # 0x18600
cmpq 0x80(%rcx), %rax
jne 0x10976
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x100, %rax            # imm = 0x100
cmpq $0x0, %rax
je 0x10976
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x101, %rcx           # imm = 0xFEFF
movq %rcx, (%rax)
movq 0x7cb8(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x5790
jmp 0x1099c
movq -0x10(%rbp), %rax
movq (%rax), %rdx
andq $0x100, %rdx            # imm = 0x100
xorl %ecx, %ecx
movl $0x1, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x184(%rax)
movq -0x10(%rbp), %rdi
callq 0x5070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: systray_state
void
systray_state(Systray *s)
{
   long flags;
   int code = 0;

   if(!(flags = ewmh_get_xembed_state(s->win)) ||!systray_enable)
      return;

   if(flags & XEMBED_MAPPED)
   {
      code = XEMBED_WINDOW_ACTIVATE;
      XMapRaised(dpy, s->win);
      setwinstate(s->win, NormalState);
   }
   else
   {
      code = XEMBED_WINDOW_DEACTIVATE;
      XUnmapWindow(dpy, s->win);
      setwinstate(s->win, WithdrawnState);
   }

   dwm_send_message(s->win, s->win, "_XEMBED", CurrentTime, code, 0, 0, 0);

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10ac0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x10a1e
jmp 0x10aba
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x10a59
movl $0x1, -0x14(%rbp)
movq 0x7bde(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5720
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10c00
jmp 0x10a83
movl $0x2, -0x14(%rbp)
movq 0x7bb1(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x5360
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c00
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0x14(%rbp), %r8
leaq 0x1c5f(%rip), %rdx      # 0x126fb
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xa230
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: ewmh_get_xembed_state
long
ewmh_get_xembed_state(Window win)
{
   Atom rf;
   int f;
   ulong n, il;
   long ret = 0;
   uchar *data = NULL;

   if(XGetWindowProperty(dpy, win, ATOM("_XEMBED_INFO"), 0L, 2, False,
            ATOM("_XEMBED_INFO"), &rf, &f, &n, &il, &data) != Success)
      return 0;

   if(rf == ATOM("_XEMBED_INFO") && n == 2)
      ret = (long)data[1];

   if(n && data)
      XFree(data);

   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq 0x7b2d(%rip), %rax      # 0x18618
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x7b1a(%rip), %rdi      # 0x18618
leaq 0x1c53(%rip), %rsi      # 0x12758
xorl %edx, %edx
callq 0x55f0
movq %rax, -0x60(%rbp)
movq 0x7b01(%rip), %rdi      # 0x18618
leaq 0x1c3a(%rip), %rsi      # 0x12758
xorl %edx, %edx
callq 0x55f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %r15
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
xorl %r9d, %r9d
leaq -0x30(%rbp), %r14
leaq -0x34(%rbp), %rbx
leaq -0x40(%rbp), %r11
leaq -0x48(%rbp), %r10
leaq -0x58(%rbp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x51a0
cmpl $0x0, %eax
je 0x10b86
movq $0x0, -0x20(%rbp)
jmp 0x10be1
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x7a83(%rip), %rdi      # 0x18618
leaq 0x1bbc(%rip), %rsi      # 0x12758
xorl %edx, %edx
callq 0x55f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0x10bc2
cmpq $0x2, -0x40(%rbp)
jne 0x10bc2
movq -0x58(%rbp), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x10bd9
cmpq $0x0, -0x58(%rbp)
je 0x10bd9
movq -0x58(%rbp), %rdi
callq 0x5070
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: setwinstate
void
setwinstate(Window win, long state)
{
   long data[] = {state, None};

   XChangeProperty(dpy, win, ATOM("WM_STATE"), ATOM("WM_STATE"), 32,
         PropModeReplace, (uchar *)data, 2);

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x79f1(%rip), %rax      # 0x18618
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x79de(%rip), %rdi      # 0x18618
leaq 0x172f(%rip), %rsi      # 0x12370
xorl %edx, %edx
callq 0x55f0
movq %rax, -0x28(%rbp)
movq 0x79c5(%rip), %rdi      # 0x18618
leaq 0x1716(%rip), %rsi      # 0x12370
xorl %edx, %edx
callq 0x55f0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq -0x20(%rbp), %rax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x5670
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: isprotodel
Bool
isprotodel(Client *c) {
   wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);

   /*   int i, n;
        Atom *protocols;
        Bool ret = False;

        if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {
        for(i = 0; !ret && i < n; i++)
        if(protocols[i] == wmatom[WMDelete])
        ret = True;
        XFree(protocols);
        }
        return ret;*/

   /*   int n;
        Atom *protocols;
        Bool ret = False;

        if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {
        while(!ret && n--)
        ret = protocols[n] == wmatom[WMDelete];
        XFree(protocols);
        }
        return ret;*/

   int  canbedel = 0;
   Atom *atom = NULL;
   int proto;
   Bool ret = False;
   if(XGetWMProtocols(dpy, c->win, &atom, &proto) && atom)
   {
      while(proto--)
         if(atom[proto] == wmatom[WMDelete])
            ++canbedel;
      if(canbedel)
         ret = True;
      XFree(atom);
   }

   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x7965(%rip), %rdi      # 0x18618
leaq 0x1684(%rip), %rsi      # 0x1233e
xorl %edx, %edx
callq 0x55f0
movq %rax, 0x7970(%rip)      # 0x18638
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq 0x7933(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x1a8(%rax), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
callq 0x56d0
cmpl $0x0, %eax
je 0x10d51
cmpq $0x0, -0x18(%rbp)
je 0x10d51
jmp 0x10d0b
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x10d3b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x790a(%rip), %rax      # 0x18638
jne 0x10d39
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10d0b
cmpl $0x0, -0xc(%rbp)
je 0x10d48
movl $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5070
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x10d9a
movq 0x7884(%rip), %rax      # 0x18600
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x10d98
movq 0x7864(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
jmp 0x10e0e
movq 0x785f(%rip), %rax      # 0x18600
cmpq 0x7850(%rip), %rax      # 0x185f8
jne 0x10dd8
movq 0x7847(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x10dd6
jmp 0x10dc5
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10db5
jmp 0x10e0c
movq 0x7819(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
cmpq 0x780b(%rip), %rax      # 0x18600
je 0x10e0a
jmp 0x10df9
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10de3
jmp 0x10e0c
jmp 0x10e0e
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10e5f
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10e5f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x77b5(%rip), %rcx      # 0x18600
movq 0x77ae(%rip), %rdx      # 0x18600
movl 0x5c(%rdx), %edx
cmpq 0xa0(%rcx,%rdx,8), %rax
je 0x10e6f
movq 0x779a(%rip), %rax      # 0x18600
movl 0x5c(%rax), %ecx
xorl $0x1, %ecx
movl %ecx, 0x5c(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x10ea0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10ea0
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq 0x7772(%rip), %rax      # 0x18600
movq 0x776b(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq %rdx, 0xa0(%rax,%rcx,8)
movq 0x7759(%rip), %rdi      # 0x18600
movq 0x7752(%rip), %rax      # 0x18600
movq 0x774b(%rip), %rcx      # 0x18600
movl 0x5c(%rcx), %ecx
movq 0xa0(%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movl $0x10, %edx
callq 0x5620
movq 0x772b(%rip), %rax      # 0x18600
cmpq $0x0, 0x80(%rax)
je 0x10eed
movq 0x771a(%rip), %rdi      # 0x18600
callq 0xbf30
jmp 0x10ef9
movq 0x770c(%rip), %rdi      # 0x18600
callq 0x8b10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: attachend
void
attachend(Client *c) {
   Client *e = c->mon->clients;
   if(!e)
   {
      attach(c);
      return;
   }

   while(e->next)
      e = e->next;

   e->next = c;
   c->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10f31
movq -0x8(%rbp), %rdi
callq 0x109b0
jmp 0x10f70
jmp 0x10f33
movq -0x10(%rbp), %rax
cmpq $0x0, 0x190(%rax)
je 0x10f52
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10f33
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x28(%rbp)
movq $-0x1, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x7640(%rip), %rdi      # 0x18618
movq -0x28(%rbp), %rsi
movq 0x765d(%rip), %rdx      # 0x18640
movq 0x7656(%rip), %r15      # 0x18640
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
xorl %r9d, %r9d
leaq -0x58(%rbp), %r14
leaq -0x2c(%rbp), %rbx
leaq -0x48(%rbp), %r11
leaq -0x50(%rbp), %r10
leaq -0x40(%rbp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x51a0
cmpl $0x0, %eax
je 0x1103c
movq $-0x1, -0x20(%rbp)
jmp 0x1105f
cmpq $0x0, -0x48(%rbp)
je 0x1104e
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5070
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cloudef[P]dwm-fork/dwm.c
// Function: cleanupmon
void
cleanupmon(Monitor *mon) {
   Monitor *m;

   if(mon == mons)
      mons = mons->next;
   else {
      for(m = mons; m && m->next != mon; m = m->next);
      m->next = mon->next;
   }
   XUnmapWindow(dpy, mon->barwin);
   XDestroyWindow(dpy, mon->barwin);
   free(mon);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x7571(%rip), %rax      # 0x185f8
jne 0x110a0
movq 0x7568(%rip), %rax      # 0x185f8
movq 0x90(%rax), %rax
movq %rax, 0x755a(%rip)      # 0x185f8
jmp 0x110fe
movq 0x7551(%rip), %rax      # 0x185f8
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x110cc
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x110d5
jmp 0x110e8
jmp 0x110d7
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x110ab
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq 0x7513(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x5360
movq 0x74fc(%rip), %rdi      # 0x18618
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
callq 0x5310
movq -0x8(%rbp), %rdi
callq 0x52b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x3dce(%rip), %rdi      # 0x5004
leaq 0x3dd7(%rip), %rsi      # 0x5014
callq 0x10d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq -0x20(%rbp), %rdi
callq 0x1d40
cmpl $0x0, %eax
je 0x1292
leaq 0x3d8b(%rip), %rdi      # 0x5016
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x27b0
movq -0x20(%rbp), %rdi
callq 0x33a0
movq -0x28(%rbp), %rdi
callq 0x1670
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1661
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
jne 0x1635
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
jmp 0x1642
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x1614
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x16c7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdi
callq 0x1600
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1683
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x10c0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x45c9
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x45d9
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x4630
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x10c0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x476d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x4747
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x47a1
leaq 0xccd(%rip), %rdi       # 0x5467
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0xcc1(%rip), %rdi       # 0x5474
movb $0x0, %al
callq 0x1080
cmpq $0x0, -0x10(%rbp)
je 0x47e3
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xca8(%rip), %rdi       # 0x5476
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x47ba
leaq 0xc91(%rip), %rdi       # 0x547b
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x8, %edi
callq 0x2130
movq %rax, -0x8(%rbp)
movl $0x40, %edi
callq 0x2130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: flush
void flush(char* str){     //flush buffer
   int i;
    for(i = 0; i < 30; i++)
        str[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x235c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x233f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: buffer_flush
void buffer_flush(char* str){     //flush buffer
   int i;
    for(i = 0; i < 4000; i++)
        str[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xfa0, -0xc(%rbp)      # imm = 0xFA0
jge 0x238f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x236f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1e, %edi
callq 0x2130
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x1e, -0x1c(%rbp)
jge 0x2413
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0xdd1a(%rip), %rax      # 0x100f0
movq (%rax,%rcx,8), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x2406
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0xdded(%rip), %rax      # 0x101e0
movq (%rax,%rcx,8), %rsi
callq 0x2050
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x243c
jmp 0x2408
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23c1
movl 0xa05e(%rip), %eax      # 0xc477
movl %eax, -0x22(%rbp)
movw 0xa058(%rip), %ax       # 0xc47b
movw %ax, -0x1e(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x2050
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./lexer.c
// Function: remove_extralines
int remove_extralines(char *B,int forward){   //remove newline characters
    char cq = B[forward];
    while(B[forward] == '\r' && B[forward++] == '\n'){	
        lineno++;
        forward++;
    }
    return forward;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0xe(%rbp)
jne 0x249e
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x24a7
jmp 0x24c1
movl 0xde23(%rip), %eax      # 0x102d0
addl $0x1, %eax
movl %eax, 0xde1a(%rip)      # 0x102d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2469
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x2a, %ecx
movb %al, -0xd(%rbp)
jne 0x250b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2516
jmp 0x2541
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x253f
movl 0xdd9a(%rip), %eax      # 0x102d0
addl $0x1, %eax
movl %eax, 0xdd91(%rip)      # 0x102d0
jmp 0x24db
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x1a6cd(%rip), %rdi     # 0x1cc28
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2140
movq 0x1a6b8(%rip), %rdi     # 0x1cc28
callq 0x2590
movq %rax, 0x1a6ac(%rip)     # 0x1cc28
movb $0x7e, 0x1b64b(%rip)    # 0x1dbce
movq 0x1a69e(%rip), %rax     # 0x1cc28
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xfa0, -0x18(%rbp)     # imm = 0xFA0
leaq 0x1a686(%rip), %rdi     # 0x1cc30
callq 0x2360
cmpq $0x0, -0x10(%rbp)
jne 0x25cb
leaq 0x9ec0(%rip), %rdi      # 0xc47d
movb $0x0, %al
callq 0x2090
xorl %edi, %edi
callq 0x21a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x25f4
movslq -0x14(%rbp), %rcx
leaq 0x1a64b(%rip), %rax     # 0x1cc30
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25d2
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x1a62d(%rip), %rdi     # 0x1cc30
movl $0x1, %edx
callq 0x2060
cmpq $0x0, %rax
je 0x261d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2625
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9e4b(%rip), %rsi      # 0xc492
callq 0x2150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x266a
leaq 0x9e37(%rip), %rdi      # 0xc495
movb $0x0, %al
callq 0x2090
jmp 0x2749
jmp 0x266c
movq -0x10(%rbp), %rdi
callq 0x2110
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2686
jmp 0x2740
movq -0x10(%rbp), %rdi
callq 0x20d0
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0x26a0
jmp 0x2740
movsbl -0x11(%rbp), %eax
cmpl $0x2a, %eax
jne 0x2728
movq -0x10(%rbp), %rdi
callq 0x20d0
cmpl $0x2a, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0x2726
jmp 0x26c6
movq -0x10(%rbp), %rdi
callq 0x20d0
cmpl $0x2a, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0x270d
movq -0x10(%rbp), %rdi
callq 0x20d0
cmpl $0x2a, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2718
jmp 0x271a
jmp 0x26c6
movq -0x10(%rbp), %rdi
callq 0x20d0
movb %al, -0x11(%rbp)
jmp 0x2728
movsbl -0x11(%rbp), %edi
movq 0xd8ad(%rip), %rax      # 0xffe0
movq (%rax), %rsi
callq 0x20e0
jmp 0x266c
movq -0x10(%rbp), %rdi
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x4328
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4306
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x4382
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x4375
movl $0x1, -0x14(%rbp)
jmp 0x4377
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4350
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: find_location
int find_location(char *token){
    int j;
    for(j=0;j<TERMS;j++){
        if(strcmp(terms[j],token)==0){
            return j;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x6e, -0x14(%rbp)
jge 0x43db
movslq -0x14(%rbp), %rcx
leaq 0xe89c(%rip), %rax      # 0x12c50
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
cmpl $0x0, %eax
jne 0x43ce
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43e2
jmp 0x43d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jge 0x443e
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cmpl $0x6d, (%rax,%rcx,4)
jne 0x4431
movl $0x1, -0x4(%rbp)
jmp 0x4445
jmp 0x4433
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4409
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: Initialise_table
void Initialise_table(int table[][TERMINALS]){ //initialise the parse table with -1's
    int i;
    int j;
    for(i=0;i<NON_TERMINALS;i++){
        for(j=0;j<TERMINALS;j++){
            table[i][j] = -1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x33, -0xc(%rbp)
jge 0x4907
movl $0x0, -0x10(%rbp)
cmpl $0x3a, -0x10(%rbp)
jge 0x48fa
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x48cc
jmp 0x48fc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x48bf
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: search
parsetree search(parsetree root, int a){       //search a node with value a in parsetree with root as its root 
    parsetree temp;

    if(root == NULL)
        return NULL;
    else if((root->value == a) && !root->isVisited){
        return root;
    }
    else if((temp=search(root->child, a))!=NULL)
        return temp;
    else if ((temp = search(root->right, a))!=NULL)
        return temp;
    else
        return NULL;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4930
movq $0x0, -0x8(%rbp)
jmp 0x49a0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4950
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x4950
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x4910
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4974
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49a0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x4910
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4998
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: initialise_stack
void initialise_stack(){    //initialise stack with -1's
    int j;
    for(j=0;j<STACK_SIZE;j++){
        stack[j] = -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x32, -0x4(%rbp)
jge 0x4dfe
movslq -0x4(%rbp), %rcx
leaq 0x18df4(%rip), %rax     # 0x1dbe0
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4ddb
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: pop
int pop(){                  //pop functionality for stack
    int temp = stack[top];
    stack[top] = -1;
    top--;
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xde35(%rip), %rcx      # 0x12c40
leaq 0x18dce(%rip), %rax     # 0x1dbe0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movslq 0xde21(%rip), %rcx      # 0x12c40
leaq 0x18dba(%rip), %rax     # 0x1dbe0
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xde0d(%rip), %eax      # 0x12c40
addl $-0x1, %eax
movl %eax, 0xde04(%rip)      # 0x12c40
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: printstack
void printstack(){          //print all elements of the stack
    int i;
    for(i=0;i<STACK_SIZE;i++){
        if(stack[i] == -1){
            break;
        }
        printf("%s ",terms[stack[i]]);
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x32, -0x4(%rbp)
jge 0x4eab
movslq -0x4(%rbp), %rcx
leaq 0x18d70(%rip), %rax     # 0x1dbe0
cmpl $-0x1, (%rax,%rcx,4)
jne 0x4e78
jmp 0x4eab
movslq -0x4(%rbp), %rcx
leaq 0x18d5d(%rip), %rax     # 0x1dbe0
movslq (%rax,%rcx,4), %rcx
leaq 0xddc2(%rip), %rax      # 0x12c50
movq (%rax,%rcx,8), %rsi
leaq 0x77c8(%rip), %rdi      # 0xc661
movb $0x0, %al
callq 0x2090
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4e5f
leaq 0x8818(%rip), %rdi      # 0xd6ca
movb $0x0, %al
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: Print_parsing_table
void Print_parsing_table(int table[][TERMINALS]){ //to print the parsing table
    int i;
    int j;
    for(i=0;i<NON_TERMINALS;i++){
        for(j=0;j<TERMINALS;j++){
            if(table[i][j] == -1){
                printf("_ ");
            }else{
                printf("%d ",table[i][j]);
            }
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x33, -0xc(%rbp)
jge 0x4f66
movl $0x0, -0x10(%rbp)
cmpl $0x3a, -0x10(%rbp)
jge 0x4f4a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x4f16
leaq 0x7758(%rip), %rdi      # 0xc665
movb $0x0, %al
callq 0x2090
jmp 0x4f3d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x7732(%rip), %rdi      # 0xc668
movb $0x0, %al
callq 0x2090
jmp 0x4f3f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ee4
leaq 0x8779(%rip), %rdi      # 0xd6ca
movb $0x0, %al
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ed3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./parser.c
// Function: removePunctuation
void removePunctuation(parsetree head){

    if(head == NULL)
        return;

    parsetree child = head->child;
    parsetree right = head->right;

    switch(head->value){
        case 55:
        case 58: 
        case 62:
        case 66:
        case 67:
        case 70:
        case 71:

        case 92: 
        case 93: 
        case 94: 
        case 95: 
        case 96: 
        case 98: 
        case 99: 
        case 101: 
        case 102: 
        case 103: 
        case 104: 

        if(head->left==NULL)
        {   
            //parsetree temp = head->parent;
            head->parent->child = head->right;
            if(head->right!=NULL)
                head->right->left = NULL;
            free(head);
            
        }

        else
        {   

            head->left->right = head->right;
            if(head->right!=NULL)
                head->right->left = head->left;
            free(head);
        }

        break;

        default: break;

    }

    removePunctuation(child);
    removePunctuation(right);

    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4f88
jmp 0x50a1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x37, %eax
je 0x500a
jmp 0x4fb1
movl -0x1c(%rbp), %eax
subl $0x3a, %eax
je 0x500a
jmp 0x4fbb
movl -0x1c(%rbp), %eax
subl $0x3e, %eax
je 0x500a
jmp 0x4fc5
movl -0x1c(%rbp), %eax
addl $-0x42, %eax
subl $0x2, %eax
jb 0x500a
jmp 0x4fd2
movl -0x1c(%rbp), %eax
addl $-0x46, %eax
subl $0x2, %eax
jb 0x500a
jmp 0x4fdf
movl -0x1c(%rbp), %eax
addl $-0x5c, %eax
subl $0x5, %eax
jb 0x500a
jmp 0x4fec
movl -0x1c(%rbp), %eax
addl $-0x62, %eax
subl $0x2, %eax
jb 0x500a
jmp 0x4ff9
movl -0x1c(%rbp), %eax
addl $-0x65, %eax
subl $0x3, %eax
ja 0x508d
jmp 0x500a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x504f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5044
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x508b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x5082
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x508f
jmp 0x508f
movq -0x10(%rbp), %rdi
callq 0x4f70
movq -0x18(%rbp), %rdi
callq 0x4f70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)