LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_pop
static void
is_pop(void)
{
	if (cmds[cip].s_code != SRCH_NOPR) {
		curwp->w_doto = cmds[cip].s_doto;
		curwp->w_dotp = cmds[cip].s_dotp;
		curwp->w_flag |= WFMOVE;
		cmds[cip].s_code = SRCH_NOPR;
	}
	if (--cip <= 0)
		cip = NSRCH - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x6195(%rip), %rcx      # 0x10b50
leaq 0x619e(%rip), %rax      # 0x10b60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x3, (%rax)
je 0xaa4b
movslq 0x617b(%rip), %rcx      # 0x10b50
leaq 0x6184(%rip), %rax      # 0x10b60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rax), %rcx
leaq 0x606a(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movslq 0x6154(%rip), %rcx      # 0x10b50
leaq 0x615d(%rip), %rax      # 0x10b60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x6043(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0x6035(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x3b(%rax)
movslq 0x6119(%rip), %rcx      # 0x10b50
leaq 0x6122(%rip), %rax      # 0x10b60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl 0x60ff(%rip), %eax      # 0x10b50
addl $-0x1, %eax
movl %eax, 0x60f6(%rip)      # 0x10b50
cmpl $0x0, %eax
jg 0xaa69
movl $0x7f, 0x60e7(%rip)     # 0x10b50
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/tcap.c
// Function: getwinsize
void getwinsize ()
{
  int cols, rows;
#ifndef FORCE_COLS
  struct winsize ws;

  ioctl (0, TIOCGWINSZ, &ws);
  cols = ws.ws_col;
  rows = ws.ws_row;
#else
  cols = FORCE_COLS;
  rows = FORCE_ROWS;
#endif
  if ((cols < 10) || (rows < 3))
    {
      puts ("Unbelievable screen size\n");
      exit (1);
    }
  term.t_ncol = cols;
  term.t_nrow = rows-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x2140
movzwl -0xe(%rbp), %eax
movl %eax, -0x4(%rbp)
movzwl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0xa, -0x4(%rbp)
jl 0xaae4
cmpl $0x3, -0x8(%rbp)
jge 0xaafa
leaq 0x1c93(%rip), %rdi      # 0xc77e
callq 0x2090
movl $0x1, %edi
callq 0x2280
movl -0x4(%rbp), %eax
movl %eax, 0x5d79(%rip)      # 0x1087c
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, 0x5d69(%rip)      # 0x10878
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/tcap.c
// Function: tcapopen
void tcapopen ()
{
  char tcbuf[1024], err_str[72];
  char *p, *tv_stype;

  if ((tv_stype = getenv ("TERM")) == NULL)
    {
      puts ("Environment variable TERM not defined\n");
      exit (1);
    }
  if ((tgetent (tcbuf, tv_stype)) != 1)
    {
      snprintf (err_str, 72, "Unknown terminal type %s\n", tv_stype);
      puts (err_str);
      exit (1);
    }
  p = tcapbuf;
  CL = tgetstr ("cl", &p);
  CM = tgetstr ("cm", &p);
  CE = tgetstr ("ce", &p);
  SE = tgetstr ("se", &p);
  SO = tgetstr ("so", &p);

  if (CE == NULL)
    eolexist = FALSE;
  if (SO != NULL && SE != NULL)
    revexist = TRUE;
  if (CL == NULL || CM == NULL)
    {
      puts ("Insufficient termcap! (needs cl & cm abilities)\n");
      exit (1);
    }
  if (p >= &tcapbuf[TCAPSLEN])	/* XXX */
    {
      puts ("Terminal description too big!\n");
      exit (1);
    }
  ttopen ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
leaq 0x1c66(%rip), %rdi      # 0xc798
callq 0x2030
movq %rax, -0x460(%rbp)
cmpq $0x0, %rax
jne 0xab5a
leaq 0x1c52(%rip), %rdi      # 0xc79d
callq 0x2090
movl $0x1, %edi
callq 0x2280
leaq -0x400(%rbp), %rdi
movq -0x460(%rbp), %rsi
movb $0x0, %al
callq 0x2290
cmpl $0x1, %eax
je 0xabab
leaq -0x450(%rbp), %rdi
movq -0x460(%rbp), %rcx
movl $0x48, %esi
leaq 0x1c36(%rip), %rdx      # 0xc7c4
movb $0x0, %al
callq 0x2130
leaq -0x450(%rbp), %rdi
callq 0x2090
movl $0x1, %edi
callq 0x2280
leaq 0x6bae(%rip), %rax      # 0x11760
movq %rax, -0x458(%rbp)
leaq 0x1c1e(%rip), %rdi      # 0xc7de
leaq -0x458(%rbp), %rsi
movb $0x0, %al
callq 0x21f0
movq %rax, 0x6bcb(%rip)      # 0x117a0
leaq 0x1c05(%rip), %rdi      # 0xc7e1
leaq -0x458(%rbp), %rsi
movb $0x0, %al
callq 0x21f0
movq %rax, 0x6bb7(%rip)      # 0x117a8
leaq 0x1bec(%rip), %rdi      # 0xc7e4
leaq -0x458(%rbp), %rsi
movb $0x0, %al
callq 0x21f0
movq %rax, 0x6ba3(%rip)      # 0x117b0
leaq 0x1bd3(%rip), %rdi      # 0xc7e7
leaq -0x458(%rbp), %rsi
movb $0x0, %al
callq 0x21f0
movq %rax, 0x6b8f(%rip)      # 0x117b8
leaq 0x1bba(%rip), %rdi      # 0xc7ea
leaq -0x458(%rbp), %rsi
movb $0x0, %al
callq 0x21f0
movq %rax, 0x6b7b(%rip)      # 0x117c0
cmpq $0x0, 0x6b63(%rip)      # 0x117b0
jne 0xac5c
leaq 0x572a(%rip), %rax      # 0x10380
movl $0x0, (%rax)
cmpq $0x0, 0x6b5c(%rip)      # 0x117c0
je 0xac7d
cmpq $0x0, 0x6b4a(%rip)      # 0x117b8
je 0xac7d
leaq 0x5dc9(%rip), %rax      # 0x10a40
movl $0x1, (%rax)
cmpq $0x0, 0x6b1b(%rip)      # 0x117a0
je 0xac91
cmpq $0x0, 0x6b19(%rip)      # 0x117a8
jne 0xaca7
leaq 0x1b55(%rip), %rdi      # 0xc7ed
callq 0x2090
movl $0x1, %edi
callq 0x2280
leaq 0x6ab2(%rip), %rax      # 0x11760
addq $0x40, %rax
cmpq %rax, -0x458(%rbp)
jb 0xacd1
leaq 0x1b5c(%rip), %rdi      # 0xc81e
callq 0x2090
movl $0x1, %edi
callq 0x2280
movb $0x0, %al
callq 0xadb0
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/termio.c
// Function: ttopen
void ttopen ()
{
  /* save terminal flags */
  if ((tcgetattr(0, &ostate) < 0) || (tcgetattr(0, &nstate) < 0))
    {
      puts ("Can't read terminal capabilites\n");
      exit (1);
    }
  cfmakeraw(&nstate);		/* set raw mode */
  nstate.c_cc[VMIN] = 1;
  nstate.c_cc[VTIME] = 0;	/* block indefinitely for a single char */
  if (tcsetattr(0, TCSADRAIN, &nstate) < 0)
    {
      puts ("Can't set terminal mode\n");
      exit (1);
    }
  /* provide a smaller terminal output buffer so that the type ahead
   * detection works better (more often) */
  setbuffer (stdout, &tobuf[0], TBUFSIZ);
  signal (SIGTSTP, SIG_DFL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
leaq 0x6a13(%rip), %rsi      # 0x117d0
callq 0x2230
cmpl $0x0, %eax
jl 0xadda
xorl %edi, %edi
leaq 0x6a3c(%rip), %rsi      # 0x1180c
callq 0x2230
cmpl $0x0, %eax
jge 0xadf0
leaq 0x1a5c(%rip), %rdi      # 0xc83d
callq 0x2090
movl $0x1, %edi
callq 0x2280
leaq 0x6a15(%rip), %rdi      # 0x1180c
callq 0x2210
movb $0x1, 0x6a20(%rip)      # 0x11823
movb $0x0, 0x6a18(%rip)      # 0x11822
xorl %edi, %edi
movl $0x1, %esi
leaq 0x69f4(%rip), %rdx      # 0x1180c
callq 0x2240
cmpl $0x0, %eax
jge 0xae38
leaq 0x1a35(%rip), %rdi      # 0xc85e
callq 0x2090
movl $0x1, %edi
callq 0x2280
movq 0x5199(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x6a07(%rip), %rsi      # 0x11850
movl $0x80, %edx
callq 0x20f0
movl $0x14, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x2190
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/termio.c
// Function: ttclose
void ttclose ()
{
  ttflush ();
  if (tcsetattr(0, TCSADRAIN, &ostate) < 0)
    {
      puts ("Can't restore terminal flags");
      exit (1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xaee0
xorl %edi, %edi
movl $0x1, %esi
leaq 0x6949(%rip), %rdx      # 0x117d0
callq 0x2240
cmpl $0x0, %eax
jge 0xaea7
leaq 0x19df(%rip), %rdi      # 0xc877
callq 0x2090
movl $0x1, %edi
callq 0x2280
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/window.c
// Function: refresh
int refresh (int f, int n)
{
  if (n >= 0)
    n++;			/* adjust to screen row */
  if (f == FALSE)
    {
      sgarbf = TRUE;
      n = 0;			/* Center dot */
    }
  curwp->w_force = n;
  curwp->w_flag |= WFFORCE;
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xaf79
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xaf93
leaq 0x53fe(%rip), %rax      # 0x10384
movl $0x1, (%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movb %al, %cl
leaq 0x5ab9(%rip), %rax      # 0x10a58
movq (%rax), %rax
movb %cl, 0x3a(%rax)
leaq 0x5aac(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/window.c
// Function: nextwind
int nextwind (int f, int n)
{
  WINDOW *wp;

  if ((wp = curwp->w_wndp) == NULL)
    wp = wheadp;

  curwp = wp;
  curbp = wp->w_bufp;
  upmode ();
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x5a83(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xaff3
leaq 0x5a84(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x5a5a(%rip), %rax      # 0x10a58
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x5a38(%rip), %rax      # 0x10a48
movq %rcx, (%rax)
movb $0x0, %al
callq 0x55e0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/window.c
// Function: prevwind
int prevwind (int f, int n)
{
  WINDOW *wp1, *wp2;

  wp1 = wheadp;
  wp2 = curwp;

  if (wp1 == wp2)
    wp2 = NULL;

  while (wp1->w_wndp != wp2)
    wp1 = wp1->w_wndp;

  curwp = wp1;
  curbp = wp1->w_bufp;
  upmode ();
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x5a2b(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x5a05(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xb06c
movq $0x0, -0x18(%rbp)
jmp 0xb06e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0xb088
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb06e
movq -0x10(%rbp), %rcx
leaq 0x59c5(%rip), %rax      # 0x10a58
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x59a3(%rip), %rax      # 0x10a48
movq %rcx, (%rax)
movb $0x0, %al
callq 0x55e0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/window.c
// Function: wpopup
WINDOW* wpopup ()
{
  WINDOW *wp;

  if (wheadp->w_wndp == NULL	/* Only 1 window */
      && splitwind (FALSE, 0) == FALSE)	/* and it won't split */
    return (NULL);
  wp = wheadp;			/* Find window to use */
  while (wp != NULL && wp == curwp)
    wp = wp->w_wndp;
  return (wp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x5421(%rip), %rax      # 0x10a70
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0xb670
xorl %esi, %esi
movl %esi, %edi
callq 0xb300
cmpl $0x0, %eax
jne 0xb670
movq $0x0, -0x8(%rbp)
jmp 0xb6bc
leaq 0x53f9(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0xb69e
movq -0x10(%rbp), %rax
leaq 0x53c3(%rip), %rcx      # 0x10a58
cmpq (%rcx), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xb6a7
jmp 0xb6b4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xb67e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	// by default ignore -o <file>
	do_output = 0;

	// Expand, linearize and show it.
	check_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		check_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x7535b(%rip), %rax     # 0x867b0
movl $0x0, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17f80
movq %rax, %rdi
callq 0x11520
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11494
jmp 0x11511
jmp 0x11496
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x114fd
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x114e1
cmpq $0x0, -0x20(%rbp)
jne 0x114e1
jmp 0x114f2
movq -0x20(%rbp), %rdi
callq 0x183f0
movq %rax, %rdi
callq 0x11520
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1149d
jmp 0x114ff
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x11496
callq 0x40380
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_symbols
static void check_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;

		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (ep && ep->entry) {
			if (dbg_entry)
				show_entry(ep);

			check_context(ep);
		}
		if (dbg_compound)
			list_compound_symbol(sym);
	} END_FOR_EACH_PTR(sym);

	if (Wsparse_error && die_if_error)
		exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11550
jmp 0x11624
jmp 0x11552
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1160c
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x115a1
cmpq $0x0, -0x10(%rbp)
jne 0x115a1
jmp 0x115fe
movq -0x10(%rbp), %rdi
callq 0x126c0
movq -0x10(%rbp), %rdi
callq 0x1b6f0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x115e7
movq -0x38(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x115e7
leaq 0x7dbc0(%rip), %rax     # 0x8f190
cmpl $0x0, (%rax)
je 0x115de
movq -0x38(%rbp), %rdi
callq 0x1a980
movq -0x38(%rbp), %rdi
callq 0x11650
leaq 0x7db96(%rip), %rax     # 0x8f184
cmpl $0x0, (%rax)
je 0x115fc
movq -0x10(%rbp), %rdi
callq 0x11890
jmp 0x115fe
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11559
jmp 0x1160e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11552
leaq 0x75235(%rip), %rax     # 0x86860
cmpl $0x0, (%rax)
je 0x11646
leaq 0x7db29(%rip), %rax     # 0x8f160
cmpl $0x0, (%rax)
je 0x11646
movl $0x1, %edi
callq 0x112d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: list_compound_symbol
static void list_compound_symbol(struct symbol *sym)
{
	struct symbol *base;

	/* Only show symbols that have a positive size */
	if (sym->bit_size <= 0)
		return;
	if (!sym->ctype.base_type)
		return;
	/* Don't show unnamed types */
	if (!sym->ident)
		return;

	if (sym->type == SYM_NODE)
		base = sym->ctype.base_type;
	else
		base = sym;
	switch (base->type) {
	case SYM_STRUCT: case SYM_UNION: case SYM_ARRAY:
		break;
	default:
		return;
	}

	info(sym->pos, "%s: compound size %u, alignment %lu",
		show_typename(sym),
		bits_to_bytes(sym->bit_size),
		sym->ctype.alignment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jg 0x118ab
jmp 0x1194b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x118bb
jmp 0x1194b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x118cb
jmp 0x1194b
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x118e9
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x118f1
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x6, %eax
subl $0x2, %eax
ja 0x11904
jmp 0x11902
jmp 0x11906
jmp 0x1194b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33f60
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x121f0
movq -0x20(%rbp), %rdx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x70(%rsi), %r8
movq 0x4(%rax), %rdi
leaq 0x517e0(%rip), %rsi     # 0x63124
movb $0x0, %al
callq 0x17830
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_instructions
static void check_instructions(struct entrypoint *ep)
{
	struct basic_block *bb;
	FOR_EACH_PTR(ep->bbs, bb) {
		bb->context = -1;
		check_bb_instructions(bb);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11994
jmp 0x11a14
jmp 0x11996
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11a00
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x119e1
cmpq $0x0, -0x10(%rbp)
jne 0x119e1
jmp 0x119f5
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x11af0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1199d
jmp 0x11a02
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11996
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_bb_context
static int check_bb_context(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
{
	if (!bb)
		return 0;
	if (bb->context == entry)
		return 0;

	/* Now that's not good.. */
	if (bb->context >= 0)
		return imbalance(ep, bb, entry, bb->context, "different lock contexts for basic block");

	bb->context = entry;
	entry += context_increase(bb, entry);
	if (entry < 0)
		return imbalance(ep, bb, entry, exit, "unexpected unlock");

	return check_children(ep, bb, entry, exit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11a49
movl $0x0, -0x4(%rbp)
jmp 0x11ae5
movq -0x18(%rbp), %rax
movl 0x58(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x11a61
movl $0x0, -0x4(%rbp)
jmp 0x11ae5
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jl 0x11a8e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x58(%rax), %ecx
leaq 0x5161d(%rip), %r8      # 0x630a1
callq 0x11ed0
movl %eax, -0x4(%rbp)
jmp 0x11ae5
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x11f40
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x11acf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq 0x51604(%rip), %r8      # 0x630c9
callq 0x11ed0
movl %eax, -0x4(%rbp)
jmp 0x11ae5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x12080
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_bb_instructions
static void check_bb_instructions(struct basic_block *bb)
{
	struct instruction *insn;
	FOR_EACH_PTR(bb->insns, insn) {
		if (!insn->bb)
			continue;
		check_one_instruction(insn);
	} END_FOR_EACH_PTR(insn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11b24
jmp 0x11ba6
jmp 0x11b26
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11b92
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11b71
cmpq $0x0, -0x10(%rbp)
jne 0x11b71
jmp 0x11b87
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11b7e
jmp 0x11b87
movq -0x10(%rbp), %rdi
callq 0x11bb0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11b2d
jmp 0x11b94
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11b26
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_one_instruction
static void check_one_instruction(struct instruction *insn)
{
	switch (insn->opcode) {
	case OP_SEXT: case OP_ZEXT:
	case OP_TRUNC:
		if (verbose)
			check_cast_instruction(insn);
		break;
	case OP_RANGE:
		check_range_instruction(insn);
		break;
	case OP_CALL:
		check_call_instruction(insn);
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0xc(%rbp)
addl $-0x34, %eax
subl $0x3, %eax
jb 0x11be6
jmp 0x11bd2
movl -0xc(%rbp), %eax
subl $0x4a, %eax
je 0x11c08
jmp 0x11bdc
movl -0xc(%rbp), %eax
subl $0x50, %eax
je 0x11bfd
jmp 0x11c13
leaq 0x7d657(%rip), %rax     # 0x8f244
cmpl $0x0, (%rax)
je 0x11bfb
movq -0x8(%rbp), %rdi
callq 0x11c20
jmp 0x11c15
movq -0x8(%rbp), %rdi
callq 0x11d20
jmp 0x11c15
movq -0x8(%rbp), %rdi
callq 0x11d50
jmp 0x11c15
jmp 0x11c15
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_cast_instruction
static void check_cast_instruction(struct instruction *insn)
{
	struct symbol *orig_type = insn->orig_type;
	if (orig_type) {
		int old = orig_type->bit_size;
		int new = insn->size;
		int oldsigned = (orig_type->ctype.modifiers & MOD_SIGNED) != 0;
		int newsigned = insn->opcode == OP_SEXT;

		if (new > old) {
			if (oldsigned == newsigned)
				return;
			if (newsigned)
				return;
			warning(insn->pos, "cast loses sign");
			return;
		}
		if (new < old) {
			warning(insn->pos, "cast drops bits");
			return;
		}
		if (oldsigned == newsigned) {
			warning(insn->pos, "cast wasn't removed");
			return;
		}
		warning(insn->pos, "cast changes sign");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11d15
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x2000, %rax           # imm = 0x2000
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x36, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x11cbf
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x11c9f
jmp 0x11d15
cmpl $0x0, -0x20(%rbp)
je 0x11ca7
jmp 0x11d15
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x51377(%rip), %rsi     # 0x6302d
movb $0x0, %al
callq 0x179a0
jmp 0x11d15
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11cdf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x51367(%rip), %rsi     # 0x6303d
movb $0x0, %al
callq 0x179a0
jmp 0x11d15
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x11cff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x51357(%rip), %rsi     # 0x6304d
movb $0x0, %al
callq 0x179a0
jmp 0x11d15
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x51353(%rip), %rsi     # 0x63061
movb $0x0, %al
callq 0x179a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_call_instruction
static void check_call_instruction(struct instruction *insn)
{
	pseudo_t fn = insn->func;
	struct ident *ident;
	static const struct checkfn check_fn[] = {
		{ &memset_ident, check_memset },
		{ &memcpy_ident, check_memcpy },
		{ &copy_to_user_ident, check_ctu },
		{ &copy_from_user_ident, check_cfu },
	};
	int i;

	if (fn->type != PSEUDO_SYM)
		return;
	ident = fn->sym->ident;
	if (!ident)
		return;
	for (i = 0; i < ARRAY_SIZE(check_fn); i++) {
		if (check_fn[i].id != ident)
			continue;
		check_fn[i].check(insn);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x4(%rax)
je 0x11d74
jmp 0x11de4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11d8d
jmp 0x11de4
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x4, %rax
jae 0x11de4
movslq -0x1c(%rbp), %rcx
leaq 0x6d037(%rip), %rax     # 0x7ede0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x11dbb
jmp 0x11dd9
movslq -0x1c(%rbp), %rcx
leaq 0x6d01a(%rip), %rax     # 0x7ede0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x11de4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11d94
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_byte_count
static void check_byte_count(struct instruction *insn, pseudo_t count)
{
	if (!count)
		return;
	if (count->type == PSEUDO_VAL) {
		unsigned long long val = count->value;
		if (Wmemcpy_max_count && val > fmemcpy_max_count)
			warning(insn->pos, "%s with byte count of %llu",
				show_ident(insn->func->sym->ident), val);
		return;
	}
	/* OK, we could try to do the range analysis here */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11e59
jmp 0x11ec7
movq -0x10(%rbp), %rax
cmpl $0x6, 0x4(%rax)
jne 0x11ec7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x749c2(%rip), %rax     # 0x86838
cmpl $0x0, (%rax)
je 0x11ec5
movq -0x18(%rbp), %rax
leaq 0x74972(%rip), %rcx     # 0x867f8
cmpq (%rcx), %rax
jbe 0x11ec5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x45130
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rax), %rdi
leaq 0x511c8(%rip), %rsi     # 0x63086
movb $0x0, %al
callq 0x179a0
jmp 0x11ec7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: imbalance
static int imbalance(struct entrypoint *ep, struct basic_block *bb, int entry, int exit, const char *why)
{
	if (Wcontext) {
		struct symbol *sym = ep->name;
		warning(bb->pos, "context imbalance in '%s' - %s", show_ident(sym->ident), why);
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
leaq 0x74923(%rip), %rax     # 0x86814
cmpl $0x0, (%rax)
je 0x11f32
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x45130
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax), %rdi
leaq 0x511b0(%rip), %rsi     # 0x630db
movb $0x0, %al
callq 0x179a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: context_increase
static int context_increase(struct basic_block *bb, int entry)
{
	int sum = 0;
	struct instruction *insn;

	FOR_EACH_PTR(bb->insns, insn) {
		int val;
		if (!insn->bb)
			continue;
		if (insn->opcode != OP_CONTEXT)
			continue;
		val = insn->increment;
		if (insn->check) {
			int current = sum + entry;
			if (!val) {
				if (!current)
					continue;
			} else if (current >= val)
				continue;
			warning(insn->pos, "context check failure");
			continue;
		}
		sum += val;
	} END_FOR_EACH_PTR(insn);
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11f7e
jmp 0x1206c
jmp 0x11f80
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x12054
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11fcf
cmpq $0x0, -0x18(%rbp)
jne 0x11fcf
jmp 0x12046
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x11fdc
jmp 0x12046
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x4f, %eax
je 0x11fec
jmp 0x12046
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x1203d
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x12019
cmpl $0x0, -0x3c(%rbp)
jne 0x12017
jmp 0x12046
jmp 0x12025
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jl 0x12023
jmp 0x12046
jmp 0x12025
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x510c6(%rip), %rsi     # 0x630fa
movb $0x0, %al
callq 0x179a0
jmp 0x12046
movl -0x38(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11f87
jmp 0x12056
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x11f80
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/sparse.c
// Function: check_children
static int check_children(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
{
	struct instruction *insn;
	struct basic_block *child;

	insn = last_instruction(bb->insns);
	if (!insn)
		return 0;
	if (insn->opcode == OP_RET)
		return entry != exit ? imbalance(ep, bb, entry, exit, "wrong count at exit") : 0;

	FOR_EACH_PTR(bb->children, child) {
		if (check_bb_context(ep, child, entry, exit))
			return -1;
	} END_FOR_EACH_PTR(child);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x121d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x120ba
movl $0x0, -0x4(%rbp)
jmp 0x121c5
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x2, %eax
jne 0x12101
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x120ef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq 0x5102b(%rip), %r8      # 0x63110
callq 0x11ed0
movl %eax, -0x50(%rbp)
jmp 0x120f6
xorl %eax, %eax
movl %eax, -0x50(%rbp)
jmp 0x120f6
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x121c5
jmp 0x12103
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1212b
jmp 0x121be
jmp 0x1212d
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x121a6
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x12178
cmpq $0x0, -0x30(%rbp)
jne 0x12178
jmp 0x1219b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x11a20
cmpl $0x0, %eax
je 0x12199
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x121c5
jmp 0x1219b
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x12134
jmp 0x121a8
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x1212d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/stats.c
// Function: show_stats
static void show_stats(get_t get, struct allocator_stats * tot)
{
	struct allocator_stats x;

	if (get)
		get(&x);
	else
		x = *tot;
	fprintf(stderr, "%16s: %8d, %10ld, %10ld, %6.2f%%, %8.2f\n",
		x.name, x.allocations, x.useful_bytes, x.total_bytes,
		100 * (double) x.useful_bytes / (x.total_bytes ? : 1),
		(double) x.useful_bytes / (x.allocations ? : 1));

	tot->allocations += x.allocations;
	tot->useful_bytes += x.useful_bytes;
	tot->total_bytes += x.total_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x401e3
leaq -0x30(%rbp), %rdi
callq *-0x8(%rbp)
jmp 0x40206
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x45de3(%rip), %rax     # 0x85ff0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, %xmm1
movaps 0x2a282(%rip), %xmm0    # 0x6a4c0
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x2a286(%rip), %xmm0    # 0x6a4d0
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x2a257(%rip), %xmm0    # 0x6a4b8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x40282
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x4028d
movl $0x1, %eax
movq %rax, -0x70(%rbp)
jmp 0x4028d
movsd -0x40(%rbp), %xmm0
movq -0x70(%rbp), %rax
movq %rax, %xmm3
movaps 0x2a21e(%rip), %xmm2    # 0x6a4c0
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0x2a222(%rip), %xmm1    # 0x6a4d0
subpd %xmm1, %xmm3
movaps %xmm3, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
addsd %xmm4, %xmm3
divsd %xmm3, %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x18(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x74(%rbp)
cmpl $0x0, %eax
je 0x402fc
movl -0x74(%rbp), %eax
movl %eax, -0x8c(%rbp)
jmp 0x40309
movl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x40309
movsd -0x88(%rbp), %xmm0
movq -0x48(%rbp), %r9
movq -0x50(%rbp), %r8
movl -0x54(%rbp), %ecx
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
movsd -0x80(%rbp), %xmm1
movl -0x8c(%rbp), %eax
movl %eax, %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
leaq 0x2a1ec(%rip), %rsi     # 0x6a52d
movb $0x2, %al
callq 0x111c0
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch3/eatyguy5.c
// Function: push_state_table
void push_state_table(lua_State *L,
                      int key,
                      int is_end_of_seq) {

  // The state of the Lua stack is given in indented comments in
  // this function to clarify the actions of each function call.

  lua_newtable(L);

    // stack = [.., {}]

  push_keypress(L, key, is_end_of_seq);

    // stack = [.., {}, key]

  lua_setfield(L, -2, "key");

    // stack = [.., {key = key}]

  lua_pushnumber(L, gettime());

    // stack = [.., {key = key}, clock]

  lua_setfield(L, -2, "clock");

    // stack = [.., {key = key, clock = clock}]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x7570
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x57d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2e813(%rip), %rdx     # 0x34081
callq 0x7a70
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x5610
movq -0x18(%rbp), %rdi
callq 0x6b20
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2e7ec(%rip), %rdx     # 0x34085
callq 0x7a70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/fsatest.c
// Function: unescape
void
unescape(char *s)
{
	// w = write index, r = read index
	int w = 0;
	for (int r = 0; s[r]; r++) {
		if (s[r] != '#')
			s[w++] = s[r];
		else if (s[r + 1] != '#')
			s[w++] = ' ';
		else
			s[w++] = s[++r];
	}
	s[w] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x12c3
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x23, %eax
je 0x125b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x12b3
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x23, %eax
je 0x1289
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
jmp 0x12b1
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x12b3
jmp 0x12b5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1216
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jacereda[P]fsatrace/src/fsatest.c
// Function: exec
void
exec(char *s)
{
#ifndef _WIN32_WINNT
	int child;
	int rc;
#endif

	char *args[1000];
	args[0] = strtok(s, " ");
	for (int i = 1; i < 1000; i++) {
		args[i] = strtok(NULL, " ");
		if (args[i] == NULL)
			break;
	}

#ifdef _WIN32_WINNT
	spawnv(P_WAIT, args[0], args);
#else
	child = fork();
	if (child == 0)
		execvp(args[0], args);
	waitpid(child, &rc, 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f60, %rsp           # imm = 0x1F60
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd56(%rip), %rsi       # 0x2050
callq 0x10a0
movq %rax, -0x1f50(%rbp)
movl $0x1, -0x1f54(%rbp)
cmpl $0x3e8, -0x1f54(%rbp)   # imm = 0x3E8
jge 0x1365
xorl %eax, %eax
movl %eax, %edi
leaq 0xd29(%rip), %rsi       # 0x2050
callq 0x10a0
movq %rax, %rcx
movslq -0x1f54(%rbp), %rax
movq %rcx, -0x1f50(%rbp,%rax,8)
movslq -0x1f54(%rbp), %rax
cmpq $0x0, -0x1f50(%rbp,%rax,8)
jne 0x1352
jmp 0x1365
jmp 0x1354
movl -0x1f54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1f54(%rbp)
jmp 0x1310
callq 0x10f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1386
movq -0x1f50(%rbp), %rdi
leaq -0x1f50(%rbp), %rsi
callq 0x10b0
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x1080
addq $0x1f60, %rsp           # imm = 0x1F60
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/file.c
// Function: count_file_lines
int count_file_lines(FILE* fp)
{
    int     c       = 0;

    size_t  y       = 0;

    rewind(fp);
    while ((c = fgetc(fp)) != EOF) {
        if (c == '\n')
            y++;
    }

    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1060
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x11c9
cmpl $0xa, -0xc(%rbp)
jne 0x11c7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x11a4
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/file.c
// Function: file_is_binary
int file_is_binary(FILE* fp)
{
    int     c   = 0;

    while ((c = fgetc(fp)) != EOF) {
        if (c <= 0x08)
            return c;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x14e4
cmpl $0x8, -0x14(%rbp)
jg 0x14e2
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14eb
jmp 0x14c3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]clangsay/src/libbenly/src/file.c
// Function: watch_fd
int watch_fd(int fd, long timeout)
{
    fd_set  fdset;

    struct  timeval tm;

    FD_ZERO(&fdset);
    FD_SET(fd, &fdset);

    tm.tv_sec = tm.tv_usec = timeout;

    return select(fd + 1, &fdset, NULL, NULL, &tm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpq $0x10, %rax
jae 0x155c
movq -0xb0(%rbp), %rax
movl -0xa4(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x152a
jmp 0x155e
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x4(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rax, -0xa0(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa0(%rbp), %r8
movq %rcx, %rdx
callq 0x1080
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.4/client.c
// Function: main
int main (){
  char* server_name = getenv ("SERVER_NAME");
  if (server_name == NULL)
    /* The SERVER_NAME environment variable was not set. Use the
     default. */
    server_name = "server.my-company.com";
  printf ("accessing server %s\n", server_name);
  /* Access the server here... */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe9e(%rip), %rdi       # 0x2004
callq 0x1030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1181
leaq 0xe93(%rip), %rax       # 0x2010
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xe9a(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/reseauMain.c
// Function: main
int main()
{
    // lecture et creation d'une instance de Chaines et de Reseau
    FILE* f = NULL;
    f = fopen("00014_burma.cha", "r");
    Chaines *c = lectureChaines(f);
    
    Reseau *R = reconstitueReseauListe(c);
    
    // affichage et l'enregistrement
    afficheChainesSVG(c, "chaineReseau");
    FILE* f2 = NULL;
    f2 = fopen("res.txt", "w");
    ecrireReseau(R, f2);
    
    afficheReseauSVG(R, "reso");

    //fermeture et liberation
    liberation_reseau(R);
    liberer_chaines(c);
    fclose(f);
    fclose(f2);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x89d(%rip), %rdi       # 0x330b
leaq 0x8a6(%rip), %rsi       # 0x331b
callq 0x10d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1520
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x87a(%rip), %rsi       # 0x331d
callq 0x20d0
movq $0x0, -0x28(%rbp)
leaq 0x873(%rip), %rdi       # 0x332a
leaq 0x6d0(%rip), %rsi       # 0x318e
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17c0
movq -0x20(%rbp), %rdi
leaq 0x853(%rip), %rsi       # 0x3332
callq 0x1a50
movq -0x20(%rbp), %rdi
callq 0x1de0
movq -0x18(%rbp), %rdi
callq 0x2670
movq -0x10(%rbp), %rdi
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/shaswata56[P]BenchUtil/BenchmarkIOPS64.c
// Function: main
int main (int argc, char** argv) {
    int n;
    if (argc == 1) {
        printf("Number of CPU cores to run Benchmark: ");
        scanf("%d", &n);
    } else {
        n = atoi(argv[1]);
    }
    printf("Benchmarking for 64 Bit Integer operations per second\n");
    initIOPS64(n);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x121e
leaq 0x3e05(%rip), %rdi      # 0x5008
movb $0x0, %al
callq 0x1050
leaq 0x3e1e(%rip), %rdi      # 0x502f
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x10b0
jmp 0x122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
leaq 0x3dfd(%rip), %rdi      # 0x5032
movb $0x0, %al
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)