LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/basic.c
// Function: forwpage
int forwpage (int f, int n)
{
  LINE *lp;

  if (f == FALSE)
    {
      n = curwp->w_ntrows - 2;	 /* Default scroll */
      if (n <= 0)		 /* Forget the overlap */
	n = 1;			 /* if tiny window */
    }
  else if (n < 0)
    return (backpage (f, -n));
  else			       /* Convert from pages */
    n *= curwp->w_ntrows;      /* to lines */
  lp = curwp->w_linep;
  while (n-- && lp != curbp->b_linep)
    lp = lforw (lp);
  curwp->w_linep = lp;
  curwp->w_dotp = lp;
  curwp->w_doto = 0;
  curwp->w_flag |= WFHARD;
  return (TRUE);
}

// Assembly:
pushq %rax
testl %edi, %edi
je 0x26d4
testl %esi, %esi
js 0x2721
leaq 0xa370(%rip), %rax      # 0xca38
movq (%rax), %rax
movsbl 0x39(%rax), %ecx
imull %esi, %ecx
jmp 0x26f1
leaq 0xa35d(%rip), %rax      # 0xca38
movq (%rax), %rax
movzbl 0x39(%rax), %ecx
cmpb $0x4, %cl
pushq $0x3
popq %rdx
cmovgel %ecx, %edx
movzbl %dl, %ecx
addl $-0x2, %ecx
leaq 0x10(%rax), %rdx
leaq 0xa32c(%rip), %rsi      # 0xca28
movq (%rsi), %rsi
incl %ecx
movq (%rdx), %rdx
decl %ecx
je 0x270e
cmpq 0x28(%rsi), %rdx
jne 0x2701
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
andq $0x0, 0x20(%rax)
orb $0x8, 0x3b(%rax)
jmp 0x2728
negl %esi
callq 0x272d
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/basic.c
// Function: backpage
int backpage (int f, int n)
{
  LINE *lp;

  if (f == FALSE)
    {
      n = curwp->w_ntrows - 2;	 /* Default scroll */
      if (n <= 0)		 /* Don't blow up if the window is tiny */
	n = 1;
    }
  else if (n < 0)
    return (forwpage (f, -n));
  else			       /* Convert from pages to lines */
    n *= curwp->w_ntrows;
  lp = curwp->w_linep;
  while (n-- && lback (lp) != curbp->b_linep)
    lp = lback (lp);
  curwp->w_linep = lp;
  curwp->w_dotp = lp;
  curwp->w_doto = 0;
  curwp->w_flag |= WFHARD;
  return (TRUE);
}

// Assembly:
pushq %rax
testl %edi, %edi
je 0x2749
testl %esi, %esi
js 0x279a
leaq 0xa2fb(%rip), %rax      # 0xca38
movq (%rax), %rax
movsbl 0x39(%rax), %ecx
imull %esi, %ecx
jmp 0x2766
leaq 0xa2e8(%rip), %rax      # 0xca38
movq (%rax), %rax
movzbl 0x39(%rax), %ecx
cmpb $0x4, %cl
pushq $0x3
popq %rdx
cmovgel %ecx, %edx
movzbl %dl, %ecx
addl $-0x2, %ecx
movq 0x10(%rax), %rdi
leaq 0xa2b7(%rip), %rdx      # 0xca28
movq (%rdx), %rdx
incl %ecx
movq %rdi, %rsi
decl %ecx
je 0x2787
movq 0x8(%rsi), %rdi
cmpq 0x28(%rdx), %rdi
jne 0x2776
movq %rsi, 0x10(%rax)
movq %rsi, 0x18(%rax)
andq $0x0, 0x20(%rax)
orb $0x8, 0x3b(%rax)
jmp 0x27a1
negl %esi
callq 0x26b8
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: swbuffer
int swbuffer (BUFFER *bp)
{
  WINDOW *wp;

  if (--curbp->b_nwnd == 0)
    {				/* Last use. */
      curbp->b_dotp = curwp->w_dotp;
      curbp->b_doto = curwp->w_doto;
      curbp->b_markp = curwp->w_markp;
      curbp->b_marko = curwp->w_marko;
    }
  curbp = bp;			/* Switch. */
  if (curbp->b_active != TRUE)
    {				/* buffer not active yet */
      /* read it in and activate it */
      readin (curbp->b_fname);
      curbp->b_dotp = lforw (curbp->b_linep);
      curbp->b_doto = 0;
      curbp->b_active = TRUE;
    }
  curwp->w_bufp = bp;
  curwp->w_linep = bp->b_linep;	/* For macros, ignored */
  curwp->w_flag |= WFMODE | WFFORCE | WFHARD; /* Quite nasty */
  if (bp->b_nwnd++ == 0)
    {				/* First use */
      curwp->w_dotp = bp->b_dotp;
      curwp->w_doto = bp->b_doto;
      curwp->w_markp = bp->b_markp;
      curwp->w_marko = bp->b_marko;
      return (TRUE);
    }
  wp = wheadp;			/* Look for old */
  while (wp != 0)
    {
      if (wp != curwp && wp->w_bufp == bp)
	{
	  curwp->w_dotp = wp->w_dotp;
	  curwp->w_doto = wp->w_doto;
	  curwp->w_markp = wp->w_markp;
	  curwp->w_marko = wp->w_marko;
	  break;
	}
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa22f(%rip), %r14      # 0xca28
movq (%r14), %rax
decb 0x31(%rax)
jne 0x282b
leaq 0xa230(%rip), %rcx      # 0xca38
movq (%rcx), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq %rbx, (%r14)
cmpb $0x1, 0x30(%rbx)
je 0x2854
leaq 0x33(%rbx), %rdi
callq 0x4492
movq (%r14), %rax
movq 0x28(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x1, 0x30(%rax)
leaq 0xa1dd(%rip), %rax      # 0xca38
movq (%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
orb $0x19, 0x3b(%rax)
movb 0x31(%rbx), %cl
leal 0x1(%rcx), %edx
movb %dl, 0x31(%rbx)
testb %cl, %cl
je 0x28b6
leaq 0xa1ce(%rip), %rcx      # 0xca50
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x28d9
cmpq %rax, %rcx
je 0x2882
cmpq %rbx, 0x8(%rcx)
jne 0x2882
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rax)
addq $0x30, %rcx
movq %rcx, %rbx
jmp 0x28d2
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rbx
movq (%rbx), %rcx
movq %rcx, 0x30(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: nextbuffer
int nextbuffer (int f, int n)
{
  BUFFER *bp;

  bp = curbp->b_bufp;
  /* cycle through the buffers to find an eligable one */
  while ((bp == NULL) || (bp->b_flag & BFTEMP))
    {
      if (bp == NULL)
	bp = bheadp;
      else
	bp = bp->b_bufp;
    }
  return (swbuffer (bp));
}

// Assembly:
pushq %rax
leaq 0xa13c(%rip), %rax      # 0xca28
movq (%rax), %rcx
leaq 0xa22a(%rip), %rax      # 0xcb20
movq (%rcx), %rdi
movq %rax, %rcx
testq %rdi, %rdi
je 0x28f6
testb $0x1, 0x32(%rdi)
movq %rdi, %rcx
jne 0x28f6
callq 0x27eb
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: killbuffer
int killbuffer (int f, int n)
{
  BUFFER *bp;
  BUFFER *bp_alt;
  char bufn[NBUFN];
  char prompt[NFILEN];
  int s;

  sprintf(prompt, "Kill Buffer: (default %s) ", curbp->b_bname);
  s = mlreply (prompt, bufn, NBUFN);

  if (s == ABORT)
	return ABORT;
  else if (s == FALSE) {
	bp = curbp;
  } else {
	/* return if cant find named buffer */
	if ((bp = bfind (bufn, FALSE, 0)) == NULL)
	  return FALSE;
  }

  /* beep if attempt to kill buffer list */
  if (bp == blistp) {
	(*term.t_beep) ();
	mlerase();
	return FALSE;
  }

  /* find a buffer to switch to, not this one and not an internal buffer */
  bp_alt = bheadp;
  while (bp_alt != NULL)
	{
	  if (bp_alt != bp && (bp_alt->b_flag & BFTEMP) != BFTEMP)
		break;
	  bp_alt = bp_alt->b_bufp;
	}

  /* no alternate buffer, try for scratch or create it */
  if (bp_alt == NULL) {
	bp_alt = get_scratch();
  }

  if (bp_alt == NULL) {
	  return (FALSE);
  }

  swbuffer(bp_alt);
  s = zotbuf(bp);
  mlerase();
  return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0xa105(%rip), %r14      # 0xca28
movl $0x83, %edx
addq (%r14), %rdx
leaq 0x56ef(%rip), %rsi      # 0x8021
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2240
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x4202
movl %eax, %ebp
cmpl $0x2, %eax
je 0x29d0
testl %ebp, %ebp
jne 0x295f
movq (%r14), %rbx
jmp 0x2975
movq %rsp, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x29df
movq %rax, %rbx
testq %rax, %rax
je 0x29d0
leaq 0xa0cc(%rip), %rax      # 0xca48
cmpq (%rax), %rbx
je 0x29bb
leaq 0xa198(%rip), %rdi      # 0xcb20
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x299d
cmpq %rbx, %rdi
je 0x2988
testb $0x1, 0x32(%rdi)
jne 0x2988
jmp 0x29aa
callq 0x2af3
movq %rax, %rdi
testq %rax, %rax
je 0x29db
callq 0x27eb
movq %rbx, %rdi
callq 0x2b1d
movl %eax, %ebp
jmp 0x29c9
leaq 0x9e96(%rip), %rcx      # 0xc858
xorl %ebp, %ebp
xorl %eax, %eax
callq *0x50(%rcx)
xorl %eax, %eax
callq 0x324c
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x29d0
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: bfind
BUFFER* bfind (char *bname, int cflag, int bflag)
{
  BUFFER *bp, *sb;
  LINE *lp;

  bp = bheadp;
  while (bp != 0)
    {
      if (strcmp (bname, bp->b_bname) == 0)
	{
	  if ((bp->b_flag & BFTEMP) != 0)
	    {
	      mlwrite ("Cannot select builtin buffer");
	      return (0);
	    }
	  return (bp);
	}
      bp = bp->b_bufp;
    }
  if (cflag != FALSE)
    {
      if ((bp = (BUFFER *) malloc (sizeof (BUFFER))) == NULL)
	return (0);
      if ((lp = lalloc (0)) == NULL)
	{
	  free (bp);
	  return (BUFFER*)0;
	}
      /* find the place in the list to insert this buffer */
      if (bheadp == NULL || strcmp (bheadp->b_bname, bname) > 0)
	{
	  /* insert at the begining */
	  bp->b_bufp = bheadp;
	  bheadp = bp;
	}
      else
	{
	  sb = bheadp;
	  while (sb->b_bufp != 0)
	    {
	      if (strcmp (sb->b_bufp->b_bname, bname) > 0)
		break;
	      sb = sb->b_bufp;
	    }

	  /* and insert it */
	  bp->b_bufp = sb->b_bufp;
	  sb->b_bufp = bp;
	}

      /* and set up the other buffer fields */
      bp->b_active = TRUE;
      bp->b_dotp = lp;
      bp->b_doto = 0;
      bp->b_markp = 0;
      bp->b_marko = 0;
      bp->b_flag = (char)bflag;
      bp->b_nwnd = 0;
      bp->b_linep = lp;
      strncpy (bp->b_fname, "", 1);
      strncpy (bp->b_bname, bname, NBUFN);
      lp->l_fp = lp;
      lp->l_bp = lp;
    }
  return (bp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xa127(%rip), %rbx      # 0xcb20
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2a33
leaq 0x83(%rbx), %rsi
movq %r14, %rdi
callq 0x2160
testl %eax, %eax
jne 0x29f9
testb $0x1, 0x32(%rbx)
je 0x2ae1
leaq 0x5665(%rip), %rdi      # 0x808a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3dec
jmp 0x2ae1
testl %r15d, %r15d
je 0x2adf
movl $0x98, %edi
callq 0x2190
testq %rax, %rax
je 0x2adf
movq %rax, %rbx
xorl %edi, %edi
xorl %eax, %eax
callq 0x4960
testq %rax, %rax
je 0x2ad7
movq %rax, %r15
leaq 0xa0b6(%rip), %r13      # 0xcb20
movq (%r13), %r12
testq %r12, %r12
je 0x2a90
leaq 0x83(%r12), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
jg 0x2a90
movq %r12, %r13
movq (%r12), %r12
jmp 0x2a6e
movq %r12, (%rbx)
movq %rbx, (%r13)
movw $0x1, 0x30(%rbx)
movq %r15, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movb %bpl, 0x32(%rbx)
movq %r15, 0x28(%rbx)
movb $0x0, 0x33(%rbx)
movq %rbx, %rdi
addq $0x83, %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2070
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x2ae1
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: zotbuf
int zotbuf (BUFFER *bp)
{
  BUFFER *bp1, *bp2;
  int s;

  /* we ony get here if there is only *scratch* left */
  if (bp->b_nwnd != 0)
	return (FALSE); /* fail silently */
  if ((s = bclear (bp)) != TRUE) /* Blow text away */
    return (s);
  free (bp->b_linep);		/* Release header line */
  bp1 = 0;			/* Find the header */
  bp2 = bheadp;
  while (bp2 != bp)
    {
      bp1 = bp2;
      bp2 = bp2->b_bufp;
    }
  bp2 = bp2->b_bufp;		/* Next one in chain */
  if (bp1 == NULL)		/* Unlink it */
    bheadp = bp2;
  else
    bp1->b_bufp = bp2;
  free (bp);			/* Release buffer block */
  return (TRUE);
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x31(%rdi)
je 0x2b26
retq
pushq %rbx
movq %rdi, %rbx
callq 0x2b73
cmpl $0x1, %eax
jne 0x2b71
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0x9fdc(%rip), %rdx      # 0xcb20
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2b46
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2b63
leaq 0x9fbd(%rip), %rax      # 0xcb20
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2040
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: bclear
int bclear (BUFFER *bp)
{
  LINE *lp;
  int s;

  if ((bp->b_flag & BFTEMP) == 0 /* Not scratch buffer */
      && (bp->b_flag & BFCHG) != 0 /* Something changed */
      && (s = mlyesno ("Discard changes")) != TRUE)
    return (s);
  bp->b_flag &= ~BFCHG;		/* Not changed */
  while ((lp = lforw (bp->b_linep)) != bp->b_linep)
    lfree (lp);
  bp->b_dotp = bp->b_linep;	/* Fix "." */
  bp->b_doto = 0;
  bp->b_markp = 0;		/* Invalidate "mark" */
  bp->b_marko = 0;
  return (TRUE);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x32(%rdi), %al
movl %eax, %ecx
andb $0x3, %cl
cmpb $0x2, %cl
jne 0x2b98
leaq 0x551c(%rip), %rdi      # 0x80a7
callq 0x3d62
cmpl $0x1, %eax
jne 0x2bc3
movb 0x32(%rbx), %al
andb $-0x3, %al
movb %al, 0x32(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
cmpq %rax, %rdi
je 0x2bb0
callq 0x49ac
jmp 0x2b9d
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: listbuffers
int listbuffers (int f, int n)
{
  WINDOW *wp;
  BUFFER *bp;
  int s;

  if ((s = makelist ()) != TRUE)
    return (s);
  if (blistp->b_nwnd == 0)
    {				/* Not on screen yet */
      if ((wp = wpopup ()) == NULL)
	return (FALSE);
      bp = wp->w_bufp;
      if (--bp->b_nwnd == 0)
	{
	  bp->b_dotp = wp->w_dotp;
	  bp->b_doto = wp->w_doto;
	  bp->b_markp = wp->w_markp;
	  bp->b_marko = wp->w_marko;
	}
      wp->w_bufp = blistp;
      ++blistp->b_nwnd;
    }
  wp = wheadp;
  while (wp != 0)
    {
      if (wp->w_bufp == blistp)
	{
	  wp->w_linep = lforw (blistp->b_linep);
	  wp->w_dotp = lforw (blistp->b_linep);
	  wp->w_doto = 0;
	  wp->w_markp = 0;
	  wp->w_marko = 0;
	  wp->w_flag |= WFMODE | WFHARD;
	}
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2c6d
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x2c63
leaq 0x9e68(%rip), %r14      # 0xca48
movq (%r14), %rcx
cmpb $0x0, 0x31(%rcx)
jne 0x2c2a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x74e4
testq %rax, %rax
je 0x2c63
movq 0x8(%rax), %rcx
decb 0x31(%rcx)
jne 0x2c20
movq 0x18(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x28(%rax), %rdx
movq %rdx, 0x18(%rcx)
movq 0x30(%rax), %rdx
movq %rdx, 0x20(%rcx)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
incb 0x31(%rcx)
leaq 0x9e1f(%rip), %rax      # 0xca50
pushq $0x1
popq %rbx
xorps %xmm0, %xmm0
movq (%rax), %rax
testq %rax, %rax
je 0x2c63
cmpq %rcx, 0x8(%rax)
jne 0x2c37
movq 0x28(%rcx), %rdx
movq (%rdx), %rdx
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
andq $0x0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
orb $0x18, 0x3b(%rax)
jmp 0x2c37
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: addline
int addline (char *text)
{
  LINE *lp;
  int ntext, i;

  ntext = strlen (text);
  if ((lp = lalloc (ntext)) == NULL)
    return (FALSE);
  for (i = 0; i < ntext; ++i)
    lputc (lp, i, text[i]);
  blistp->b_linep->l_bp->l_fp = lp; /* Hook onto the end */
  lp->l_bp = blistp->b_linep->l_bp;
  blistp->b_linep->l_bp = lp;
  lp->l_fp = blistp->b_linep;
  if (blistp->b_dotp == blistp->b_linep) /* If "." is at the end */
    blistp->b_dotp = lp;	/* move it to new line */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r14
xorl %ebp, %ebp
movl %r14d, %edi
xorl %eax, %eax
callq 0x4960
testq %rax, %rax
je 0x2e74
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0x2e35
movb (%rbx,%rcx), %dl
movb %dl, 0x18(%rax,%rcx)
incq %rcx
jmp 0x2e24
leaq 0x9c0c(%rip), %rcx      # 0xca48
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
pushq $0x1
popq %rbp
cmpq 0x28(%rcx), %rdx
jne 0x2e74
movq %rax, 0x8(%rcx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/buffer.c
// Function: itoa
void itoa (char buf[], int width, int num)
{
  buf[width] = 0;		/* End of string */
  while (num >= 10)
    {				/* Conditional digits */
      buf[--width] = (char)((num % 10) + '0');
      num /= 10;
    }
  buf[--width] = (char)(num + '0'); /* Always 1 digit */
  while (width != 0)		    /* Pad with blanks */
    buf[--width] = ' ';
}

// Assembly:
movl %edx, %eax
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
movslq %esi, %rcx
leaq (%rdi,%rcx), %r9
decq %r9
movb $0x0, 0x1(%r9)
leal -0x1(%rcx), %esi
shlq $0x20, %rcx
addq %r8, %rcx
pushq $0xa
popq %r10
cmpl $0xa, %eax
jl 0x2ebe
xorl %edx, %edx
divl %r10d
orb $0x30, %dl
movb %dl, (%r9)
decl %esi
addq %r8, %rcx
decq %r9
jmp 0x2ea4
addb $0x30, %al
sarq $0x20, %rcx
movb %al, (%rdi,%rcx)
movslq %esi, %rax
movq %rax, %rcx
subq $0x1, %rcx
jb 0x2edd
movb $0x20, -0x1(%rdi,%rax)
movq %rcx, %rax
jmp 0x2ecd
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: movecursor
void movecursor (int row, int col)
{
  if (row != ttrow || col != ttcol)
    {
      ttrow = row;
      ttcol = col;
      (*term.t_move) (row, col);
    }
}

// Assembly:
cmpl %edi, 0x8f2a(%rip)      # 0xc150
jne 0x3231
cmpl %esi, 0x8f26(%rip)      # 0xc154
jne 0x3231
retq
movl %edi, 0x8f19(%rip)      # 0xc150
movl %esi, 0x8f17(%rip)      # 0xc154
leaq 0x9614(%rip), %rax      # 0xc858
movq 0x38(%rax), %rcx
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: mlerase
void mlerase ()
{
  int i;

  movecursor (term.t_nrow, 0);
  if (eolexist == TRUE)
    (*term.t_eeol) ();
  else
    {
      for (i = 0; i < term.t_ncol - 1; i++)
	(*term.t_putchar) (' ');
      movecursor (term.t_nrow, 1);	  /* force the move! */
      movecursor (term.t_nrow, 0);
    }
  (*term.t_flush) ();
  mpresf = FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x9601(%rip), %r14      # 0xc858
movl (%r14), %edi
xorl %esi, %esi
callq 0x3220
leaq 0x90f8(%rip), %rax      # 0xc360
cmpl $0x1, (%rax)
jne 0x3275
xorl %eax, %eax
callq *0x40(%r14)
jmp 0x32a5
pushq $0x20
popq %rbx
xorl %ebp, %ebp
movl 0x4(%r14), %eax
decl %eax
cmpl %eax, %ebp
jge 0x3290
movl %ebx, %edi
xorl %eax, %eax
callq *0x28(%r14)
incl %ebp
jmp 0x327a
movl (%r14), %edi
pushq $0x1
popq %rsi
callq 0x3220
movl (%r14), %edi
xorl %esi, %esi
callq 0x3220
xorl %eax, %eax
callq *0x30(%r14)
leaq 0x9772(%rip), %rax      # 0xca24
andl $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: vtinit
void vtinit ()
{
  VIDEO *vp;
  //char *malloc ();
  int i;

  (*term.t_open) ();
  (*term.t_rev) (FALSE);
  vscreen = (VIDEO **) malloc (term.t_nrow * sizeof (VIDEO *));

  if (vscreen == NULL)
    exit (1);

  pscreen = (VIDEO **) malloc (term.t_nrow * sizeof (VIDEO *));

  if (pscreen == NULL)
    exit (1);

  for (i = 0; i < term.t_nrow; ++i)
    {
      vp = (VIDEO *) malloc (sizeof (VIDEO) + term.t_ncol);

      if (vp == NULL)
	exit (1);

      vp->v_flag = 0;
      vscreen[i] = vp;
      vp = (VIDEO *) malloc (sizeof (VIDEO) + term.t_ncol);

      if (vp == NULL)
	exit (1);

      vp->v_flag = 0;
      pscreen[i] = vp;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x9592(%rip), %r15      # 0xc858
xorl %eax, %eax
callq *0x10(%r15)
xorl %edi, %edi
xorl %eax, %eax
callq *0x58(%r15)
movslq (%r15), %r14
leaq (,%r14,8), %rbx
movq %rbx, %rdi
callq 0x2190
movq %rax, 0x9602(%rip)      # 0xc8f0
testq %rax, %rax
je 0x3361
movq %rbx, %rdi
callq 0x2190
movq %rax, 0x95f6(%rip)      # 0xc8f8
testq %rax, %rax
je 0x3361
movslq 0x4(%r15), %rbx
addq $0x4, %rbx
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x335b
movq %rbx, %rdi
callq 0x2190
testq %rax, %rax
je 0x3361
andw $0x0, (%rax)
movq 0x95ba(%rip), %rcx      # 0xc8f0
movq %rax, (%rcx,%r15,8)
movq %rbx, %rdi
callq 0x2190
testq %rax, %rax
je 0x3361
andw $0x0, (%rax)
movq 0x95a6(%rip), %rcx      # 0xc8f8
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x3319
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: vtputc
void vtputc (int c)
{
  VIDEO *vp;

  vp = vscreen[vtrow];

  if (vtcol >= term.t_ncol)
    {
      vtcol = (vtcol + 0x07) & ~0x07;
      vp->v_text[term.t_ncol - 1] = '$';
    }
  else if (c == '\t')
    {
      do
	{
	  vtputc (' ');
	}
      while ((vtcol & 0x07) != 0);
    }
  else if (c < 0x20 || c == 0x7F)
    {
      vtputc ('^');
      vtputc (c ^ 0x40);
    }
  else
    vp->v_text[vtcol++] = c;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x94b3(%rip), %r14      # 0xc858
pushq $0x5e
popq %rbp
movq 0x9541(%rip), %rax      # 0xc8f0
movslq 0x952a(%rip), %rcx      # 0xc8e0
movq (%rax,%rcx,8), %rax
movl 0x9524(%rip), %ecx      # 0xc8e4
movl 0x4(%r14), %edx
cmpl %edx, %ecx
jge 0x33eb
cmpl $0x9, %ebx
je 0x33ff
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x3414
movl %ebp, %edi
callq 0x3398
xorl $0x40, %ebx
jmp 0x33a8
addl $0x7, %ecx
andl $-0x8, %ecx
movl %ecx, 0x94ed(%rip)      # 0xc8e4
decl %edx
movb $0x24, %bl
movl %edx, %ecx
jmp 0x341d
pushq $0x20
popq %rbx
movl %ebx, %edi
callq 0x3398
testb $0x7, 0x94d4(%rip)      # 0xc8e4
jne 0x3402
jmp 0x3424
leal 0x1(%rcx), %edx
movl %edx, 0x94c7(%rip)      # 0xc8e4
movslq %ecx, %rcx
movb %bl, 0x2(%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: vtpute
void vtpute (int c)
{
  VIDEO *vp;

  vp = vscreen[vtrow];

  if (vtcol >= term.t_ncol)
    {
      vtcol = (vtcol + 0x07) & ~0x07;
      vp->v_text[term.t_ncol - 1] = '$';
    }
  else if (c == '\t')
    {
      do
	{
	  vtpute (' ');
	}
      while (((vtcol + lbound) & 0x07) != 0);
    }
  else if (c < 0x20 || c == 0x7F)
    {
      vtpute ('^');
      vtpute (c ^ 0x40);
    }
  else
    {
      if (vtcol >= 0)
	vp->v_text[vtcol] = c;
      ++vtcol;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x9422(%rip), %r14      # 0xc858
pushq $0x5e
popq %rbp
movq 0x94b0(%rip), %rax      # 0xc8f0
movslq 0x9499(%rip), %rcx      # 0xc8e0
movq (%rax,%rcx,8), %rcx
movl 0x9493(%rip), %eax      # 0xc8e4
movslq 0x4(%r14), %rdx
cmpl %edx, %eax
jge 0x347c
cmpl $0x9, %ebx
je 0x348f
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x34ab
movl %ebp, %edi
callq 0x3429
xorl $0x40, %ebx
jmp 0x3439
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, 0x945c(%rip)      # 0xc8e4
movb $0x24, 0x1(%rdx,%rcx)
jmp 0x34c1
pushq $0x20
popq %rbx
movl %ebx, %edi
callq 0x3429
movl 0x9449(%rip), %eax      # 0xc8e8
addl 0x943f(%rip), %eax      # 0xc8e4
testb $0x7, %al
jne 0x3492
jmp 0x34c1
testl %eax, %eax
js 0x34b9
movb %bl, 0x2(%rcx,%rax)
movl 0x942b(%rip), %eax      # 0xc8e4
incl %eax
movl %eax, 0x9423(%rip)      # 0xc8e4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: vteeol
void vteeol ()
{
  VIDEO *vp;

  vp = vscreen[vtrow];
  while (vtcol < term.t_ncol)
    vp->v_text[vtcol++] = ' ';
}

// Assembly:
movq 0x9423(%rip), %rax      # 0xc8f0
movslq 0x940c(%rip), %rcx      # 0xc8e0
movq (%rax,%rcx,8), %rax
leaq 0x9379(%rip), %rcx      # 0xc858
movslq 0x93fe(%rip), %rdx      # 0xc8e4
cmpl 0x4(%rcx), %edx
jge 0x34fb
leal 0x1(%rdx), %esi
movl %esi, 0x93f0(%rip)      # 0xc8e4
movb $0x20, 0x2(%rax,%rdx)
jmp 0x34df
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: updext
void updext ()
{
  LINE *lp;			/* pointer to current line */
  int rcursor;			/* real cursor location */
  int j;			/* index into line */

  /* calculate what column the real cursor will end up in */
  rcursor = ((curcol - term.t_ncol) % term.t_scrsiz) + term.t_margin;
  lbound = curcol - rcursor + 1;

  /* scan through the line outputing characters to the virtual screen */
  /* once we reach the left edge */
  vtmove (currow, -lbound);	/* start scanning offscreen */
  lp = curwp->w_dotp;		/* line to output */
  for (j = 0; j < llength (lp); ++j) /* until the end-of-line */
    vtpute (lgetc (lp, j));
  /* truncate the virtual line */
  vteeol ();
  /* and put a '$' in column 1 */
  vscreen[currow]->v_text[0] = '$';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8e4b(%rip), %rax      # 0xcb14
movl (%rax), %ecx
leaq 0x8b86(%rip), %rsi      # 0xc858
movl %ecx, %eax
subl 0x4(%rsi), %eax
cltd
idivl 0xc(%rsi)
addl 0x8(%rsi), %edx
movl %ecx, %eax
subl %edx, %eax
negl %edx
addl %edx, %ecx
incl %ecx
movl %ecx, 0x8bfa(%rip)      # 0xc8e8
leaq 0x8e1b(%rip), %rbx      # 0xcb10
movl (%rbx), %ecx
notl %eax
movl %ecx, 0x8be1(%rip)      # 0xc8e0
movl %eax, 0x8bdf(%rip)      # 0xc8e4
leaq 0x8d2c(%rip), %rax      # 0xca38
movq (%rax), %rax
movq 0x18(%rax), %r14
xorl %r15d, %r15d
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jge 0x3d2f
movzbl 0x18(%r14,%r15), %edi
callq 0x3429
incq %r15
jmp 0x3d16
callq 0x34c6
movq 0x8bb5(%rip), %rax      # 0xc8f0
movslq (%rbx), %rcx
movq (%rax,%rcx,8), %rax
movb $0x24, 0x2(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: mlyesno
int mlyesno (char *prompt)
{
  char c;			/* input character */
  char buf[NPAT];		/* prompt to user */

  for (;;)
    {
      /* build and prompt the user */
      strncpy (buf, prompt, 60);
      strncat (buf, " [y/n]? ", 9);
      mlwrite (buf);

      /* get the responce */
      c = (*term.t_getchar) ();
      if (c == BELL)		 /* Bail out! */
	return (ABORT);
      if (c == 'y' || c == 'Y')
	return (TRUE);
      if (c == 'n' || c == 'N')
	return (FALSE);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq %rsp, %r15
pushq $0x3c
popq %r12
movabsq $0x203f5d6e2f795b20, %r13 # imm = 0x203F5D6E2F795B20
leaq 0x8acd(%rip), %rbp      # 0xc858
pushq $0x2
popq %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2070
movq %r15, %rdi
callq 0x20d0
movq %r13, (%rsp,%rax)
movb $0x0, 0x8(%rsp,%rax)
movq %r15, %rdi
xorl %eax, %eax
callq 0x3dec
xorl %eax, %eax
callq *0x20(%rbp)
cmpb $0x7, %al
je 0x3ddb
movl %eax, %ecx
andb $-0x21, %cl
cmpb $0x4e, %cl
je 0x3dd9
andl $0xdf, %eax
cmpl $0x59, %eax
jne 0x3d8e
pushq $0x1
popq %rbx
jmp 0x3ddb
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: mlwrite
void mlwrite(char *fmt, ...)
{
  static char buffer[256];

  va_list args;
  va_start (args, fmt);
  vsprintf(buffer, fmt, args);
  va_end(args);

  if (eolexist == FALSE)
    {
      mlerase ();
      (*term.t_flush) ();
    }

  movecursor (term.t_nrow, 0);
  mlputs(buffer);

  if (eolexist == TRUE)
    (*term.t_eeol)();

  (*term.t_flush)();
  mpresf = TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3e4d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8a8c(%rip), %rdi      # 0xc900
movq %r10, %rsi
callq 0x21f0
leaq 0x84dd(%rip), %rbx      # 0xc360
cmpl $0x0, (%rbx)
jne 0x3e99
callq 0x324c
leaq 0x89c4(%rip), %rcx      # 0xc858
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x89b8(%rip), %r14      # 0xc858
movl (%r14), %edi
xorl %esi, %esi
callq 0x3220
leaq 0x8a4f(%rip), %rdi      # 0xc900
callq 0x420a
cmpl $0x1, (%rbx)
jne 0x3ec1
xorl %eax, %eax
callq *0x40(%r14)
xorl %eax, %eax
callq *0x30(%r14)
leaq 0x8b56(%rip), %rax      # 0xca24
movl $0x1, (%rax)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/display.c
// Function: mlputs
void mlputs (char *s)
{
  int c;

  while ((c = *s++) != 0)
    {
      (*term.t_putchar) (c);
      ++ttcol;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8640(%rip), %r14      # 0xc858
movsbl (%rbx), %edi
testl %edi, %edi
je 0x4230
incq %rbx
xorl %eax, %eax
callq *0x28(%r14)
incl 0x7f26(%rip)            # 0xc154
jmp 0x4218
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/file.c
// Function: makename
void makename (char bname[], char fname[])
{
  char *cp1, *cp2;

  cp1 = &fname[0];
  while (*cp1 != 0)
    ++cp1;

  while (cp1 != &fname[0] && cp1[-1] != '/')
    --cp1;
  cp2 = &bname[0];
  while (cp2 != &bname[NBUFN - 1] && *cp1 != 0 && *cp1 != ';')
    *cp2++ = *cp1++;
  *cp2 = 0;
}

// Assembly:
xorl %eax, %eax
cmpb $0x0, (%rsi,%rax)
leaq 0x1(%rax), %rax
jne 0x444b
jmp 0x4465
leaq -0x1(%rax), %rcx
cmpb $0x2f, -0x2(%rsi,%rax)
movq %rcx, %rax
je 0x446d
cmpq $0x1, %rax
jne 0x4457
jmp 0x4470
addq %rcx, %rsi
xorl %eax, %eax
cmpq $0xf, %rax
je 0x448d
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0x448d
cmpl $0x3b, %ecx
je 0x448d
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x4472
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/file.c
// Function: filewrite
int filewrite (int f, int n)
{
  WINDOW *wp;
  char fname[NFILEN];
  int s;

  if ((s = mlreply ("Write File: ", fname, NFILEN)) != TRUE)
    return (s);
  if ((s = writeout (fname)) == TRUE)
    {
      strncpy (curbp->b_fname, fname, NFILEN);
      curbp->b_flag &= ~BFCHG;
      wp = wheadp;		/* Update mode lines */
      while (wp != NULL)
	{
	  if (wp->w_bufp == curbp)
	    wp->w_flag |= WFMODE;
	  wp = wp->w_wndp;
	}
    }
  return (s);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x3bd0(%rip), %rdi      # 0x8229
movq %rsp, %rsi
pushq $0x50
popq %rdx
callq 0x4202
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x46b4
movq %rsp, %rdi
callq 0x46be
testl %eax, %eax
je 0x46b2
movl %eax, %ebx
leaq 0x83a8(%rip), %rax      # 0xca28
movq (%rax), %r14
leaq 0x33(%r14), %rdi
movq %rsp, %rsi
pushq $0x50
popq %rdx
callq 0x2070
andb $-0x3, 0x32(%r14)
leaq 0x83b2(%rip), %rax      # 0xca50
movq (%rax), %rax
testq %rax, %rax
je 0x46b4
cmpq %r14, 0x8(%rax)
jne 0x469e
orb $0x10, 0x3b(%rax)
jmp 0x469e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/file.c
// Function: writeout
int writeout (char *fn)
{
  LINE *lp;
  int nline, s;

  if ((s = ffwopen (fn)) != FIOSUC) /* Open writes message */
    return (FALSE);
  mlwrite ("[Writing]");	/* tell us were writing */
  lp = lforw (curbp->b_linep);	/* First line */
  nline = 0;			/* Number of lines */
  while (lp != curbp->b_linep)
    {
      if ((s = ffputline (&lp->l_text[0], llength (lp))) != FIOSUC)
	break;
      ++nline;
      lp = lforw (lp);
    }
  if (s == FIOSUC)
    {				/* No write error */
      s = ffclose ();
      if (s == FIOSUC)
	{			/* No close error */
	  if (nline == 1)
	    mlwrite ("[Wrote 1 line]");
	  else
	    mlwrite ("[Wrote %d lines]", nline);
	}
    }
  else				/* ignore close error */
    ffclose ();			/* if a write error */
  if (s != FIOSUC)		/* some sort of error */
    return (FALSE);
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x47f4
xorl %ebp, %ebp
testl %eax, %eax
jne 0x4759
leaq 0x3b68(%rip), %rdi      # 0x8243
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3dec
leaq 0x833d(%rip), %r14      # 0xca28
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %rax, %r15
movq (%r15), %r15
cmpq %rax, %r15
je 0x4719
leaq 0x18(%r15), %rdi
movl 0x14(%r15), %esi
callq 0x484d
testl %eax, %eax
jne 0x473b
incl %ebx
movq (%r14), %rax
movq 0x28(%rax), %rax
jmp 0x46f5
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4825
testl %eax, %eax
jne 0x4759
cmpl $0x1, %ebx
jne 0x4746
leaq 0x3b1b(%rip), %rdi      # 0x824d
xorl %eax, %eax
callq 0x3dec
jmp 0x4756
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4825
jmp 0x4759
leaq 0x3b0f(%rip), %rdi      # 0x825c
movl %ebx, %esi
xorl %eax, %eax
callq 0x3dec
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/file.c
// Function: filesave
int filesave (int f, int n)
{
  WINDOW *wp;
  int s;

  if ((curbp->b_flag & BFCHG) == 0) /* Return, no changes */
    return (TRUE);
  if (curbp->b_fname[0] == 0)
    {				/* Must have a name */
      mlwrite ("No file name");
      return (FALSE);
    }
  if ((s = writeout (curbp->b_fname)) == TRUE)
    {
      curbp->b_flag &= ~BFCHG;
      wp = wheadp;		/* Update mode lines */
      while (wp != NULL)
	{
	  if (wp->w_bufp == curbp)
	    wp->w_flag |= WFMODE;
	  wp = wp->w_wndp;
	}
    }
  return (s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x82b7(%rip), %r14      # 0xca28
movq (%r14), %rdi
testb $0x2, 0x32(%rdi)
jne 0x477f
pushq $0x1
popq %rbx
jmp 0x47ca
cmpb $0x0, 0x33(%rdi)
je 0x47b6
addq $0x33, %rdi
callq 0x46be
testl %eax, %eax
je 0x47c8
movl %eax, %ebx
movq (%r14), %rax
andb $-0x3, 0x32(%rax)
leaq 0x82ae(%rip), %rcx      # 0xca50
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x47ca
cmpq %rax, 0x8(%rcx)
jne 0x47a2
orb $0x10, 0x3b(%rcx)
jmp 0x47a2
leaq 0x3a79(%rip), %rdi      # 0x8236
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3dec
jmp 0x47ca
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/fileio.c
// Function: ffputline
int ffputline (char buf[], int nbuf)
{
  int i;

  for (i = 0; i < nbuf; ++i)
    fputc (buf[i] & 0xFF, ffp);

  fputc ('\n', ffp);

  if (ferror (ffp))
    {
      mlwrite ("Write I/O error");
      return (FIOERR);
    }
  return (FIOSUC);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x487b
movzbl (%r14,%r15), %edi
movq 0x818f(%rip), %rsi      # 0xca00
callq 0x2150
incq %r15
jmp 0x4860
movq 0x817e(%rip), %rsi      # 0xca00
pushq $0xa
popq %rdi
callq 0x2150
movq 0x816f(%rip), %rdi      # 0xca00
callq 0x2090
testl %eax, %eax
je 0x48ad
leaq 0x39fc(%rip), %rdi      # 0x829d
xorl %eax, %eax
callq 0x3dec
pushq $0x3
popq %rax
jmp 0x48af
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/fileio.c
// Function: ffgetline
int ffgetline (char buf[], int nbuf)
{
  int c, i;

  i = 0;

  while ((c = fgetc (ffp)) != EOF && c != '\n')
    {
      if (i >= nbuf - 2)
	{
	  buf[nbuf - 2] = c;	   /* store last char read */
	  buf[nbuf - 1] = 0;	   /* and terminate it */
	  mlwrite ("File has long line");
	  return (FIOLNG);
	}
      buf[i++] = c;
    }

  if (c == EOF)
    {
      if (ferror (ffp))
	{
	  mlwrite ("File read error");
	  return (FIOERR);
	}
      if (i != 0)
	{
	  mlwrite ("File has funny line at EOF");
	  return (FIOERR);
	}
      return (FIOEOF);
    }
  buf[i] = 0;
  return (FIOSUC);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x2(%r14), %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
movq 0x8123(%rip), %rdi      # 0xca00
callq 0x2140
cmpl $-0x1, %eax
je 0x4903
cmpl $0xa, %eax
je 0x48fa
cmpq %r15, %r12
je 0x491c
movb %al, (%rbx,%r15)
incq %r15
jmp 0x48d6
movb $0x0, (%rbx,%r15)
xorl %eax, %eax
jmp 0x4952
movq 0x80f6(%rip), %rdi      # 0xca00
callq 0x2090
testl %eax, %eax
je 0x493c
leaq 0x39a6(%rip), %rdi      # 0x82c0
jmp 0x4948
movslq %ebp, %rcx
movb %al, (%rbx,%rcx)
movslq %r14d, %rax
movb $0x0, -0x1(%rbx,%rax)
leaq 0x397c(%rip), %rdi      # 0x82ad
xorl %eax, %eax
callq 0x3dec
pushq $0x4
jmp 0x4951
testq %r15, %r15
je 0x495b
leaq 0x3988(%rip), %rdi      # 0x82d0
xorl %eax, %eax
callq 0x3dec
pushq $0x3
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
jmp 0x4951
nop
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/line.c
// Function: lalloc
LINE* lalloc (int used)
{
  LINE *lp;
  int size;
  //char *malloc ();

  size = (used + NBLOCK - 1) & ~(NBLOCK - 1);
  if (size == 0)	       /* Assume that an empty */
    size = NBLOCK;	       /* line is for type-in */
  if ((lp = (LINE *) malloc (sizeof (LINE) + size)) == NULL)
    {
      mlwrite ("Cannot allocate %d bytes", size);
      return (NULL);
    }
  lp->l_size = size;
  lp->l_used = used;
  return (lp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %r14d
leal 0xf(%r14), %eax
andl $-0x10, %eax
pushq $0x10
popq %rbx
cmovnel %eax, %ebx
movslq %ebx, %rdi
addq $0x20, %rdi
callq 0x2190
movq %rax, %r15
testq %rax, %rax
je 0x4993
movl %ebx, 0x10(%r15)
movl %r14d, 0x14(%r15)
jmp 0x49a3
leaq 0x3951(%rip), %rdi      # 0x82eb
movl %ebx, %esi
xorl %eax, %eax
callq 0x3dec
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/line.c
// Function: lchange
void lchange (int flag)
{
  WINDOW *wp;

  if (curbp->b_nwnd != 1)      /* Ensure hard */
    flag = WFHARD;
  if ((curbp->b_flag & BFCHG) == 0)
    {			       /* First change, so */
      flag |= WFMODE;	       /* update mode lines */
      curbp->b_flag |= BFCHG;
    }
  wp = wheadp;
  while (wp != NULL)
    {
      if (wp->w_bufp == curbp)
	wp->w_flag |= flag;
      wp = wp->w_wndp;
    }
}

// Assembly:
leaq 0x7fe5(%rip), %rax      # 0xca28
movq (%rax), %rax
movb 0x32(%rax), %dl
cmpb $0x1, 0x31(%rax)
pushq $0x8
popq %rcx
cmovel %edi, %ecx
testb $0x2, %dl
jne 0x4a61
orl $0x10, %ecx
orb $0x2, %dl
movb %dl, 0x32(%rax)
leaq 0x7fe8(%rip), %rdx      # 0xca50
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4a7b
cmpq %rax, 0x8(%rdx)
jne 0x4a68
orb %cl, 0x3b(%rdx)
jmp 0x4a68
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/line.c
// Function: lnewline
int lnewline ()
{
  WINDOW *wp;
  char *cp1, *cp2;
  LINE *lp1, *lp2;
  int doto;

  lchange (WFHARD);
  lp1 = curwp->w_dotp;	       /* Get the address and */
  doto = curwp->w_doto;	       /* offset of "." */
  if ((lp2 = lalloc (doto)) == NULL)	/* New first half line */
    return (FALSE);
  cp1 = &lp1->l_text[0];       /* Shuffle text around */
  cp2 = &lp2->l_text[0];
  while (cp1 != &lp1->l_text[doto])
    *cp2++ = *cp1++;
  cp2 = &lp1->l_text[0];
  while (cp1 != &lp1->l_text[lp1->l_used])
    *cp2++ = *cp1++;
  lp1->l_used -= doto;
  lp2->l_bp = lp1->l_bp;
  lp1->l_bp = lp2;
  lp2->l_bp->l_fp = lp2;
  lp2->l_fp = lp1;
  wp = wheadp;		       /* Windows */
  while (wp != NULL)
    {
      if (wp->w_linep == lp1)
	wp->w_linep = lp2;
      if (wp->w_dotp == lp1)
	{
	  if (wp->w_doto < doto)
	    wp->w_dotp = lp2;
	  else
	    wp->w_doto -= doto;
	}
      if (wp->w_markp == lp1)
	{
	  if (wp->w_marko < doto)
	    wp->w_markp = lp2;
	  else
	    wp->w_marko -= doto;
	}
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x8
popq %rdi
callq 0x4a3c
leaq 0x7daf(%rip), %rax      # 0xca38
movq (%rax), %rax
movq 0x18(%rax), %r14
movq 0x20(%rax), %rbx
movl %ebx, %edi
callq 0x4960
testq %rax, %rax
je 0x4d4c
leaq 0x18(%r14), %rcx
movslq %ebx, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x4cc1
movb 0x18(%r14,%rsi), %dil
movb %dil, 0x18(%rax,%rsi)
incq %rsi
jmp 0x4cad
movq %rcx, %rsi
leaq (%rsi,%rdx), %r8
movslq 0x14(%r14), %rdi
leaq (%rcx,%rdi), %r9
cmpq %r9, %r8
je 0x4ce0
movb (%r8), %dil
movb %dil, (%rsi)
incq %rsi
jmp 0x4cc4
subl %ebx, %edi
movl %edi, 0x14(%r14)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%rax), %rcx
movq %rax, (%rcx)
movq %r14, (%rax)
leaq 0x7d4d(%rip), %rsi      # 0xca50
pushq $0x1
popq %rcx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x4d4e
cmpq %r14, 0x10(%rsi)
jne 0x4d18
movq %rax, 0x10(%rsi)
cmpq %r14, 0x18(%rsi)
jne 0x4d31
movq 0x20(%rsi), %rdi
subq %rdx, %rdi
jge 0x4d2d
movq %rax, 0x18(%rsi)
jmp 0x4d31
movq %rdi, 0x20(%rsi)
cmpq %r14, 0x28(%rsi)
jne 0x4d06
movq 0x30(%rsi), %rdi
subq %rdx, %rdi
jge 0x4d46
movq %rax, 0x28(%rsi)
jmp 0x4d06
movq %rdi, 0x30(%rsi)
jmp 0x4d06
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/line.c
// Function: kinsert
int kinsert (int c)
{
  //char *realloc ();
  //char *malloc ();
  char *nbufp;

  if (kused == ksize)
    {
      if (ksize == 0)	       /* first time through? */
	nbufp = malloc (KBLOCK); /* alloc the first block */
      else		       /* or re allocate a bigger block */
	nbufp = realloc (kbufp, ksize + KBLOCK);
      if (nbufp == NULL)	       /* abort if it fails */
	return (FALSE);
      kbufp = nbufp;	       /* point our global at it */
      ksize += KBLOCK;	       /* and adjust the size */
    }
  kbufp[kused++] = c;
  return (TRUE);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x7b29(%rip), %rsi      # 0xca10
cmpq 0x7b2a(%rip), %rsi      # 0xca18
jne 0x4f0a
testq %rsi, %rsi
je 0x4f13
movq 0x7b0c(%rip), %rdi      # 0xca08
addq $0x400, %rsi            # imm = 0x400
callq 0x21d0
jmp 0x4f1d
movq 0x7af7(%rip), %rax      # 0xca08
jmp 0x4f3b
movl $0x400, %edi            # imm = 0x400
callq 0x2190
testq %rax, %rax
je 0x4f4e
movq %rax, 0x7adf(%rip)      # 0xca08
addq $0x400, 0x7ae4(%rip) # imm = 0x400
movq 0x7ad5(%rip), %rsi      # 0xca10
leaq 0x1(%rsi), %rcx
movq %rcx, 0x7aca(%rip)      # 0xca10
movb %bl, (%rax,%rsi)
pushq $0x1
popq %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0x4f4c
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/line.c
// Function: kdelete
void kdelete ()
{
  if (kbufp != NULL)
    {
      free ((char *) kbufp);
      kbufp = NULL;
      kused = 0;
      ksize = 0;
    }
}

// Assembly:
movq 0x78e6(%rip), %rdi      # 0xca08
testq %rdi, %rdi
je 0x5149
pushq %rax
callq 0x2040
andq $0x0, 0x78d3(%rip)      # 0xca08
andq $0x0, 0x78d3(%rip)      # 0xca10
andq $0x0, 0x78d3(%rip)      # 0xca18
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/main.c
// Function: edinit
void edinit (char bname[])
{
  BUFFER *bp;
  WINDOW *wp;

  bp = bfind (bname, TRUE, 0);	/* First buffer */
  blistp = bfind ("[List]", TRUE, BFTEMP); /* Buffer list buffer */
  wp = (WINDOW *) malloc (sizeof (WINDOW)); /* First window */
  if (bp == NULL || wp == NULL || blistp == NULL)
    exit (1);
  curbp = bp;			/* Make this current */
  wheadp = wp;
  curwp = wp;
  wp->w_wndp = NULL;		/* Initialize window */
  wp->w_bufp = bp;
  bp->b_nwnd = 1;		/* Displayed */
  wp->w_linep = bp->b_linep;
  wp->w_dotp = bp->b_linep;
  wp->w_doto = 0;
  wp->w_markp = NULL;
  wp->w_marko = 0;
  wp->w_toprow = 0;
  wp->w_ntrows = term.t_nrow - 1; /* "-1" for mode line */
  wp->w_force = 0;
  wp->w_flag = WFMODE | WFHARD;	/* Full */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x29df
movq %rax, %rbx
leaq 0x301b(%rip), %rdi      # 0x8387
movl %ebp, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x29df
movq %rax, %r14
movq %rax, 0x76c7(%rip)      # 0xca48
pushq $0x40
popq %rdi
callq 0x2190
testq %rbx, %rbx
je 0x53e9
testq %rax, %rax
je 0x53e9
testq %r14, %r14
je 0x53e9
movq %rbx, 0x7689(%rip)      # 0xca28
movq %rax, 0x76aa(%rip)      # 0xca50
movq %rax, 0x768b(%rip)      # 0xca38
andq $0x0, (%rax)
movq %rbx, 0x8(%rax)
movb $0x1, 0x31(%rbx)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x29(%rax)
leaq 0x7481(%rip), %rcx      # 0xc858
movb (%rcx), %cl
decb %cl
movb %cl, 0x39(%rax)
movw $0x1800, 0x3a(%rax)     # imm = 0x1800
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/main.c
// Function: execute
int execute (int c, int f, int n)
{
  KEYTAB *ktp;
  int status;

  ktp = &keytab[0];	       /* Look in key table */
  while (ktp->k_fp != NULL)
    {
      if (ktp->k_code == c)
	{
	  /* block if not suitable for a read only buffer */
	  if (ktp->k_flag == BFRO && (curwp->w_bufp->b_flag & BFRO) == BFRO)
		{
		  return rdonly();
		}
	  else 
		{
		  thisflag = 0;
		  status = (*ktp->k_fp) (f, n);
		  lastflag = thisflag;
		  return (status);
		}
	}
      ++ktp;
    }


  if ((c >= 0x20 && c <= 0x7E)	/* Self inserting */
      || (c >= 0xA0 && c <= 0xFE))
    {
	  /* can we self insert */
	  if (BFRO == (curwp->w_bufp->b_flag & BFRO))
		return rdonly();

      if (n <= 0)
		{			/* Fenceposts */
		  lastflag = 0;
		  return (n < 0 ? FALSE : TRUE);
		}

      thisflag = 0;		/* For the future */
      status = linsert (n, c);
      lastflag = thisflag;
      return (status);
    }
  
  mlwrite ("\007[Key not bound]"); /* complain */
  lastflag = 0;			/* Fake last flags */
  return (FALSE);
}

// Assembly:
pushq %rbx
movl %edi, %eax
leaq 0x6f85(%rip), %rdi      # 0xc380
movq -0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x5414
movswl -0x10(%rdi), %r8d
cmpl %eax, %r8d
je 0x544b
addq $0x18, %rdi
jmp 0x53fb
movl %eax, %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
addl $-0x20, %ecx
cmpl $0x5e, %ecx
ja 0x547e
movq 0x760d(%rip), %rcx      # 0xca38
movq 0x8(%rcx), %rcx
testb $0x4, 0x32(%rcx)
jne 0x5497
testl %edx, %edx
jle 0x54b7
andl $0x0, 0x7618(%rip)      # 0xca58
movl %edx, %edi
movl %eax, %esi
callq 0x4a7c
jmp 0x5470
cmpl $0x4, (%rdi)
jne 0x5461
movq 0x75e1(%rip), %rax      # 0xca38
movq 0x8(%rax), %rax
testb $0x4, 0x32(%rax)
jne 0x5497
andl $0x0, 0x75f0(%rip)      # 0xca58
movl %esi, %edi
movl %edx, %esi
xorl %eax, %eax
callq *%rcx
movl 0x75e2(%rip), %ecx      # 0xca58
movl %ecx, 0x75b4(%rip)      # 0xca30
jmp 0x54b5
leaq 0x2f09(%rip), %rdi      # 0x838e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3dec
andl $0x0, 0x759b(%rip)      # 0xca30
jmp 0x54b3
leaq 0x73ba(%rip), %rcx      # 0xc858
xorl %ebx, %ebx
xorl %eax, %eax
callq *0x50(%rcx)
leaq 0x2f55(%rip), %rdi      # 0x8401
xorl %eax, %eax
callq 0x3dec
movl %ebx, %eax
popq %rbx
retq
andl $0x0, 0x7572(%rip)      # 0xca30
xorl %ebx, %ebx
testl %edx, %edx
sete %bl
jmp 0x54b3
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/main.c
// Function: getkey
int getkey ()
{
  int c;

  c = (*term.t_getchar) ();

  if (c == METACH)
    {				/* Apply M- prefix */
      c = getctl ();
      return (META | c);
    }
  if (c >= 0x00 && c <= 0x1F)	/* C0 control -> C- */
    c = CTRL | (c + '@');
  return (c);
}

// Assembly:
pushq %rax
leaq 0x7389(%rip), %rcx      # 0xc858
xorl %eax, %eax
callq *0x20(%rcx)
cmpl $0x1b, %eax
jne 0x54e5
callq 0x54f4
orl $0x200, %eax            # imm = 0x200
jmp 0x54f2
movl %eax, %ecx
orl $0x140, %eax            # imm = 0x140
cmpl $0x20, %ecx
cmovael %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/main.c
// Function: getctl
int getctl ()
{
  int c;

  c = (*term.t_getchar) ();
  if (c >= 'a' && c <= 'z')	/* Force to upper */
    c -= 0x20;
  if (c >= 0x00 && c <= 0x1F)	/* C0 control -> C- */
    c = CTRL | (c + '@');
  return (c);
}

// Assembly:
pushq %rax
leaq 0x735c(%rip), %rcx      # 0xc858
xorl %eax, %eax
callq *0x20(%rcx)
leal -0x61(%rax), %ecx
leal -0x20(%rax), %edx
cmpl $0x1a, %ecx
cmovbl %edx, %eax
movl %eax, %ecx
orl $0x140, %ecx            # imm = 0x140
cmpl $0x20, %eax
cmovbl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/hughbarney[P]pEmacs/main.c
// Function: quit
int quit (int f, int n)
{
  int s;

  if (f != FALSE	       /* Argument forces it */
      || anycb () == FALSE     /* All buffers clean */
      || (s = mlyesno ("Modified buffers exist. Leave anyway")) == TRUE)
    {
      vttidy ();
      exit (0);
    }
  mlwrite ("");
  return (s);
}

// Assembly:
pushq %rbx
testl %edi, %edi
jne 0x5552
xorl %eax, %eax
callq 0x2ede
testl %eax, %eax
je 0x5552
leaq 0x2e6b(%rip), %rdi      # 0x839f
callq 0x3d62
cmpl $0x1, %eax
je 0x5552
movl %eax, %ebx
leaq 0x327b(%rip), %rdi      # 0x87c2
xorl %eax, %eax
callq 0x3dec
movl %ebx, %eax
popq %rbx
retq
xorl %eax, %eax
callq 0x3369
xorl %edi, %edi
callq 0x2250