LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0xa39c(%rip), %rax      # 0xd900
movslq 0xa385(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rax
movl 0xa37f(%rip), %ecx      # 0xd8f4
leaq 0xa2ec(%rip), %r14      # 0xd868
movl 0x4(%r14), %edx
cmpl %edx, %ecx
jge 0x35ca
movl %edi, %ebx
cmpl $0x9, %ebx
je 0x35de
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x35f3
movl $0x5e, %edi
callq 0x3559
xorl $0x40, %ebx
movq 0xa34f(%rip), %rax      # 0xd900
movslq 0xa338(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rax
movl 0xa332(%rip), %ecx      # 0xd8f4
movl 0x4(%r14), %edx
cmpl %edx, %ecx
jl 0x3586
addl $0x7, %ecx
andl $-0x8, %ecx
movl %ecx, 0xa31e(%rip)      # 0xd8f4
decl %edx
movb $0x24, %bl
movl %edx, %ecx
jmp 0x35fc
movl $0x20, %edi
callq 0x3559
testb $0x7, 0xa305(%rip)      # 0xd8f4
jne 0x35de
jmp 0x3603
leal 0x1(%rcx), %edx
movl %edx, 0xa2f8(%rip)      # 0xd8f4
movslq %ecx, %rcx
movb %bl, 0x2(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0xa2ea(%rip), %rax      # 0xd900
movslq 0xa2d3(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rcx
movl 0xa2cd(%rip), %eax      # 0xd8f4
leaq 0xa23a(%rip), %r14      # 0xd868
movl 0x4(%r14), %edx
cmpl %edx, %eax
jge 0x367c
movl %edi, %ebx
cmpl $0x9, %ebx
je 0x3692
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x36ae
movl $0x5e, %edi
callq 0x360b
xorl $0x40, %ebx
movq 0xa29d(%rip), %rax      # 0xd900
movslq 0xa286(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rcx
movl 0xa280(%rip), %eax      # 0xd8f4
movl 0x4(%r14), %edx
cmpl %edx, %eax
jl 0x3638
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, 0xa26c(%rip)      # 0xd8f4
movslq %edx, %rax
movb $0x24, 0x1(%rax,%rcx)
jmp 0x36c6
movl $0x20, %edi
callq 0x360b
movl 0xa256(%rip), %eax      # 0xd8f8
addl 0xa24c(%rip), %eax      # 0xd8f4
testb $0x7, %al
jne 0x3692
jmp 0x36c6
testl %eax, %eax
js 0x36be
movl %eax, %eax
movb %bl, 0x2(%rcx,%rax)
movl 0xa236(%rip), %eax      # 0xd8f4
incl %eax
movl %eax, 0xa22e(%rip)      # 0xd8f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/display.c
// Function: vteeol
void vteeol ()
{
  VIDEO *vp;

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

// Assembly:
movl 0xa220(%rip), %ecx      # 0xd8f4
leaq 0xa18d(%rip), %rax      # 0xd868
cmpl 0x4(%rax), %ecx
jge 0x370e
movq 0xa219(%rip), %rdx      # 0xd900
movslq 0xa202(%rip), %rsi      # 0xd8f0
movq (%rdx,%rsi,8), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0xa1f9(%rip)      # 0xd8f4
movslq %ecx, %rcx
movb $0x20, 0x2(%rdx,%rcx)
movl 0xa1eb(%rip), %ecx      # 0xd8f4
cmpl 0x4(%rax), %ecx
jl 0x36f2
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
leaq 0x9a42(%rip), %rax      # 0xdb24
movl (%rax), %esi
leaq 0x977d(%rip), %rbx      # 0xd868
movl 0x4(%rbx), %ecx
movl %esi, %eax
subl %ecx, %eax
cltd
idivl 0xc(%rbx)
addl 0x8(%rbx), %edx
movl %esi, %eax
subl %edx, %eax
negl %edx
addl %esi, %edx
incl %edx
movl %edx, 0x97ef(%rip)      # 0xd8f8
leaq 0x9a10(%rip), %r14      # 0xdb20
movl (%r14), %edx
notl %eax
movl %edx, 0x97d5(%rip)      # 0xd8f0
movl %eax, 0x97d3(%rip)      # 0xd8f4
leaq 0x9920(%rip), %rdx      # 0xda48
movq (%rdx), %rdx
movq 0x18(%rdx), %r15
cmpl $0x0, 0x14(%r15)
jle 0x4159
xorl %r12d, %r12d
movzbl 0x18(%r15,%r12), %edi
callq 0x360b
incq %r12
movslq 0x14(%r15), %rax
cmpq %rax, %r12
jl 0x4139
movl 0x979e(%rip), %eax      # 0xd8f4
movl 0x4(%rbx), %ecx
cmpl %ecx, %eax
jge 0x418a
movq 0x979c(%rip), %rcx      # 0xd900
movslq 0x9785(%rip), %rdx      # 0xd8f0
movq (%rcx,%rdx,8), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x977c(%rip)      # 0xd8f4
cltq
movb $0x20, 0x2(%rcx,%rax)
movl 0x976f(%rip), %eax      # 0xd8f4
cmpl 0x4(%rbx), %eax
jl 0x416f
movq 0x976f(%rip), %rax      # 0xd900
movslq (%r14), %rcx
movq (%rax,%rcx,8), %rax
movb $0x24, 0x2(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movabsq $0x203f5d6e2f795b20, %r15 # imm = 0x203F5D6E2F795B20
leaq 0x9688(%rip), %r12      # 0xd868
movl $0x3c, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2070
movq %r14, %rdi
callq 0x20d0
movq %r15, (%rsp,%rax)
movb $0x0, 0x8(%rsp,%rax)
movq %r14, %rdi
xorl %eax, %eax
callq 0x4246
xorl %eax, %eax
callq *0x20(%r12)
cmpb $0x7, %al
je 0x4231
movl %eax, %ecx
andb $-0x21, %cl
cmpb $0x4e, %cl
je 0x4238
andl $0xdf, %eax
cmpl $0x59, %eax
jne 0x41e0
movl $0x1, %eax
jmp 0x423a
movl $0x2, %eax
jmp 0x423a
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %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 0x42a9
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 0x9640(%rip), %rdi      # 0xd910
movq %r10, %rsi
callq 0x2200
leaq 0x9091(%rip), %rbx      # 0xd370
cmpl $0x0, (%rbx)
jne 0x42f5
callq 0x3384
leaq 0x9578(%rip), %rcx      # 0xd868
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x956c(%rip), %r14      # 0xd868
movl (%r14), %edi
cmpl %edi, 0x8e5b(%rip)      # 0xd160
jne 0x4310
cmpl $0x0, 0x8e56(%rip)      # 0xd164
je 0x4328
movl %edi, 0x8e4a(%rip)      # 0xd160
movl $0x0, 0x8e44(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%r14)
movb 0x95e2(%rip), %al       # 0xd910
testb %al, %al
je 0x4352
leaq 0x95d8(%rip), %r15      # 0xd911
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r14)
incl 0x8e1c(%rip)            # 0xd164
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x4339
cmpl $0x1, (%rbx)
jne 0x435d
xorl %eax, %eax
callq *0x40(%r14)
xorl %eax, %eax
callq *0x30(%r14)
leaq 0x96ca(%rip), %rax      # 0xda34
movl $0x1, (%rax)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/display.c
// Function: mlputs
void mlputs (char *s)
{
  int c;

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

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x4745
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq %rbx
leaq 0x9142(%rip), %r14      # 0xd868
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r14)
incl 0x8a2f(%rip)            # 0xd164
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x4726
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4972
jmp 0x498c
leaq -0x1(%rax), %rcx
cmpb $0x2f, -0x2(%rsi,%rax)
movq %rcx, %rax
je 0x4994
cmpq $0x1, %rax
jne 0x497e
jmp 0x4997
addq %rcx, %rsi
leaq 0xf(%rdi), %rax
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %edx
testl %edx, %edx
je 0x49b8
cmpl $0x3b, %edx
je 0x49b8
movb %dl, (%rdi,%rcx)
incq %rcx
cmpq $0xf, %rcx
jne 0x499d
jmp 0x49be
addq %rcx, %rdi
movq %rdi, %rax
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4681(%rip), %rdi      # 0x9229
movq %rsp, %rsi
movl $0x50, %edx
callq 0x4705
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x4c16
movq %rsp, %rdi
callq 0x4c20
testl %eax, %eax
je 0x4c0d
movl %eax, %ebx
leaq 0x8e67(%rip), %rax      # 0xda38
movq (%rax), %r14
leaq 0x33(%r14), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x2070
andb $-0x3, 0x32(%r14)
leaq 0x8e6f(%rip), %rax      # 0xda60
movq (%rax), %rax
testq %rax, %rax
je 0x4c11
cmpq %r14, 0x8(%rax)
jne 0x4c03
orb $0x10, 0x3b(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x4bf9
jmp 0x4c16
xorl %ebx, %ebx
jmp 0x4c16
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d7c
xorl %ebp, %ebp
testl %eax, %eax
je 0x4c3f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45fd(%rip), %rdi      # 0x9243
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
leaq 0x8de2(%rip), %r14      # 0xda38
movq (%r14), %rax
movq 0x28(%rax), %rax
movq (%rax), %r15
cmpq %rax, %r15
je 0x4ca6
leaq 0x18(%r15), %rdi
movl 0x14(%r15), %esi
callq 0x4dd9
testl %eax, %eax
jne 0x4cd6
incl %ebx
movq (%r15), %r15
movq (%r14), %rax
cmpq 0x28(%rax), %r15
jne 0x4c65
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4daf
testl %eax, %eax
jne 0x4c32
cmpl $0x1, %ebx
jne 0x4cbc
leaq 0x45b0(%rip), %rdi      # 0x924d
xorl %eax, %eax
callq 0x4246
jmp 0x4ccc
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4daf
movl $0x0, %ebp
testl %eax, %eax
jne 0x4c32
leaq 0x4599(%rip), %rdi      # 0x925c
movl %ebx, %esi
xorl %eax, %eax
callq 0x4246
movl $0x1, %ebp
jmp 0x4c32
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4daf
jmp 0x4c32
// File: /workspace/github_c_makefile_star2_O3/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 0x8d49(%rip), %r14      # 0xda38
movq (%r14), %rdi
movl $0x1, %ebx
testb $0x2, 0x32(%rdi)
je 0x4d50
cmpb $0x0, 0x33(%rdi)
je 0x4d3c
addq $0x33, %rdi
callq 0x4c20
testl %eax, %eax
je 0x4d4e
movq (%r14), %rcx
andb $-0x3, 0x32(%rcx)
leaq 0x8d42(%rip), %rdx      # 0xda60
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4d50
cmpq %rcx, 0x8(%rdx)
jne 0x4d30
orb $0x10, 0x3b(%rdx)
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x4d26
movl %eax, %ebx
jmp 0x4d50
leaq 0x44f3(%rip), %rdi      # 0x9236
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
jmp 0x4d50
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
testl %esi, %esi
jle 0x4e04
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
movzbl (%rbx,%r15), %edi
movq 0x8c19(%rip), %rsi      # 0xda10
callq 0x2160
incq %r15
cmpq %r15, %r14
jne 0x4deb
movq 0x8c05(%rip), %rsi      # 0xda10
movl $0xa, %edi
callq 0x2160
movq 0x8bf4(%rip), %rdi      # 0xda10
callq 0x2090
testl %eax, %eax
je 0x4e3a
leaq 0x4471(%rip), %rdi      # 0x929d
xorl %eax, %eax
callq 0x4246
movl $0x3, %eax
jmp 0x4e3c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8ba6(%rip), %rdi      # 0xda10
callq 0x2150
cmpl $-0x1, %eax
je 0x4e90
cmpl $0xa, %eax
je 0x4e87
cmpq %r15, %r12
je 0x4ea9
movb %al, (%rbx,%r15)
incq %r15
jmp 0x4e63
movb $0x0, (%rbx,%r15)
xorl %eax, %eax
jmp 0x4ee4
movq 0x8b79(%rip), %rdi      # 0xda10
callq 0x2090
testl %eax, %eax
je 0x4ecc
leaq 0x4419(%rip), %rdi      # 0x92c0
jmp 0x4ed8
movslq %ebp, %rcx
movb %al, (%rbx,%rcx)
movslq %r14d, %rax
movb $0x0, -0x1(%rbx,%rax)
leaq 0x43ef(%rip), %rdi      # 0x92ad
xorl %eax, %eax
callq 0x4246
movl $0x4, %eax
jmp 0x4ee4
testq %r15, %r15
je 0x4eed
leaq 0x43f8(%rip), %rdi      # 0x92d0
xorl %eax, %eax
callq 0x4246
movl $0x3, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %eax
jmp 0x4ee4
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %ebx
cmovnel %eax, %ebx
movslq %ebx, %rdi
addq $0x20, %rdi
callq 0x21a0
movq %rax, %r15
testq %rax, %rax
je 0x4f29
movl %ebx, 0x10(%r15)
movl %r14d, 0x14(%r15)
jmp 0x4f39
leaq 0x43bb(%rip), %rdi      # 0x92eb
movl %ebx, %esi
xorl %eax, %eax
callq 0x4246
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8a53(%rip), %rax      # 0xda38
movq (%rax), %rax
movb 0x32(%rax), %dl
cmpb $0x1, 0x31(%rax)
movl $0x8, %ecx
cmovel %edi, %ecx
testb $0x2, %dl
jne 0x5005
orl $0x10, %ecx
orb $0x2, %dl
movb %dl, 0x32(%rax)
leaq 0x8a54(%rip), %rdx      # 0xda60
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x501f
cmpq %rax, 0x8(%rdx)
jne 0x500c
orb %cl, 0x3b(%rdx)
jmp 0x500c
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x8, %edi
callq 0x4fde
leaq 0x87e4(%rip), %rax      # 0xda48
movq (%rax), %rax
movq 0x18(%rax), %r14
movq 0x20(%rax), %rbx
movl %ebx, %edi
callq 0x4ef4
testq %rax, %rax
je 0x5347
leaq 0x18(%r14), %rcx
movq %rbx, %rdx
shlq $0x20, %rdx
movslq %ebx, %rdx
movq %rcx, %rsi
je 0x52ad
leaq (%r14,%rdx), %rsi
addq $0x18, %rsi
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, 0x18(%rax,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x529c
movslq 0x14(%r14), %rdi
leaq (%rcx,%rdi), %r8
cmpq %r8, %rsi
je 0x52d6
movq %rcx, %r8
movb (%rsi), %dil
incq %rsi
movb %dil, (%r8)
incq %r8
movslq 0x14(%r14), %rdi
leaq (%rcx,%rdi), %r9
cmpq %r9, %rsi
jne 0x52bd
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 0x8767(%rip), %rcx      # 0xda60
movq (%rcx), %rsi
movl $0x1, %ecx
testq %rsi, %rsi
je 0x5349
cmpq %r14, 0x10(%rsi)
jne 0x5310
movq %rax, 0x10(%rsi)
cmpq %r14, 0x18(%rsi)
jne 0x5329
movq 0x20(%rsi), %rdi
subq %rdx, %rdi
jge 0x5325
movq %rax, 0x18(%rsi)
jmp 0x5329
movq %rdi, 0x20(%rsi)
cmpq %r14, 0x28(%rsi)
jne 0x5342
movq 0x30(%rsi), %rdi
subq %rdx, %rdi
jge 0x533e
movq %rax, 0x28(%rsi)
jmp 0x5342
movq %rdi, 0x30(%rsi)
movq (%rsi), %rsi
jmp 0x5301
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x854b(%rip), %rsi      # 0xda20
cmpq 0x854c(%rip), %rsi      # 0xda28
jne 0x54f8
testq %rsi, %rsi
je 0x5501
movq 0x852e(%rip), %rdi      # 0xda18
addq $0x400, %rsi            # imm = 0x400
callq 0x21e0
jmp 0x550b
movq 0x8519(%rip), %rax      # 0xda18
jmp 0x5529
movl $0x400, %edi            # imm = 0x400
callq 0x21a0
testq %rax, %rax
je 0x553e
movq %rax, 0x8501(%rip)      # 0xda18
addq $0x400, 0x8506(%rip) # imm = 0x400
movq 0x84f7(%rip), %rsi      # 0xda20
leaq 0x1(%rsi), %rcx
movq %rcx, 0x84ec(%rip)      # 0xda20
movb %bl, (%rax,%rsi)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x553c
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/line.c
// Function: kdelete
void kdelete ()
{
  if (kbufp != NULL)
    {
      free ((char *) kbufp);
      kbufp = NULL;
      kused = 0;
      ksize = 0;
    }
}

// Assembly:
movq 0x82f2(%rip), %rdi      # 0xda18
testq %rdi, %rdi
je 0x574c
pushq %rax
callq 0x2040
xorl %eax, %eax
movq %rax, 0x82de(%rip)      # 0xda18
movq %rax, 0x82df(%rip)      # 0xda20
movq %rax, 0x82e0(%rip)      # 0xda28
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2a42
movq %rax, %rbx
leaq 0x39ac(%rip), %rdi      # 0x9387
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x2a42
movq %rax, %r14
movq %rax, 0x8062(%rip)      # 0xda58
movl $0x40, %edi
callq 0x21a0
testq %rbx, %rbx
je 0x5a66
testq %rax, %rax
je 0x5a66
testq %r14, %r14
je 0x5a66
movq %rbx, 0x8022(%rip)      # 0xda38
movq %rax, 0x8043(%rip)      # 0xda60
movq %rax, 0x8024(%rip)      # 0xda48
movq $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 0x7e17(%rip), %rcx      # 0xd868
movb (%rcx), %cl
decb %cl
movb %cl, 0x39(%rax)
movw $0x1800, 0x3a(%rax)     # imm = 0x1800
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x790e(%rip), %rcx      # 0xd388
testq %rcx, %rcx
je 0x5ae8
movswl 0x78fa(%rip), %edi      # 0xd380
cmpl %eax, %edi
jne 0x5a93
leaq 0x78ef(%rip), %rdi      # 0xd380
jmp 0x5ab1
leaq 0x78e6(%rip), %rdi      # 0xd380
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x5ae8
movswl 0x18(%rdi), %r8d
addq $0x18, %rdi
cmpl %eax, %r8d
jne 0x5a9a
cmpl $0x4, 0x10(%rdi)
jne 0x5ac8
movq 0x7f8a(%rip), %rax      # 0xda48
movq 0x8(%rax), %rax
testb $0x4, 0x32(%rax)
jne 0x5b3e
movl $0x0, 0x7f96(%rip)      # 0xda68
movl %esi, %edi
movl %edx, %esi
xorl %eax, %eax
callq *%rcx
movl 0x7f88(%rip), %ecx      # 0xda68
movl %ecx, 0x7f5a(%rip)      # 0xda40
jmp 0x5b5c
movl %eax, %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
addl $-0x20, %ecx
cmpl $0x5e, %ecx
ja 0x5b22
movq 0x7f49(%rip), %rcx      # 0xda48
movq 0x8(%rcx), %rcx
testb $0x4, 0x32(%rcx)
jne 0x5b3e
testl %edx, %edx
jle 0x5b5e
movl $0x0, 0x7f51(%rip)      # 0xda68
movl %edx, %edi
movl %eax, %esi
callq 0x5020
jmp 0x5ada
leaq 0x3865(%rip), %rdi      # 0x938e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
movl $0x0, 0x7f04(%rip)      # 0xda40
jmp 0x5b5a
leaq 0x7d23(%rip), %rcx      # 0xd868
xorl %ebx, %ebx
xorl %eax, %eax
callq *0x50(%rcx)
leaq 0x38ae(%rip), %rdi      # 0x9401
xorl %eax, %eax
callq 0x4246
movl %ebx, %eax
popq %rbx
retq
movl $0x0, 0x7ed8(%rip)      # 0xda40
sete %al
movzbl %al, %ebx
jmp 0x5b5a
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x7cf0(%rip), %rbx      # 0xd868
xorl %eax, %eax
callq *0x20(%rbx)
cmpl $0x1b, %eax
jne 0x5ba7
xorl %eax, %eax
callq *0x20(%rbx)
leal -0x61(%rax), %ecx
leal -0x20(%rax), %edx
cmpl $0x1a, %ecx
cmovael %eax, %edx
movl %edx, %eax
orl $0x140, %eax            # imm = 0x140
cmpl $0x20, %edx
cmovael %edx, %eax
orl $0x200, %eax            # imm = 0x200
jmp 0x5bb4
movl %eax, %ecx
orl $0x140, %eax            # imm = 0x140
cmpl $0x20, %ecx
cmovael %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7caa(%rip), %rcx      # 0xd868
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_O3/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 0x5c14
xorl %eax, %eax
callq 0x2fb3
testl %eax, %eax
je 0x5c14
leaq 0x37a9(%rip), %rdi      # 0x939f
callq 0x41be
cmpl $0x1, %eax
je 0x5c14
movl %eax, %ebx
leaq 0x3ba1(%rip), %rdi      # 0x97aa
xorl %eax, %eax
callq 0x4246
movl %ebx, %eax
popq %rbx
retq
xorl %eax, %eax
callq 0x3509
xorl %edi, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: ctlxlp
int ctlxlp (int f, int n)
{
  if (kbdmip != NULL || kbdmop != NULL)
    {
      mlwrite ("Not now");
      return (FALSE);
    }
  mlwrite ("[Start macro]");
  kbdmip = &kbdm[0];
  return (TRUE);
}

// Assembly:
pushq %rbx
movq 0x7e46(%rip), %rax      # 0xda70
orq 0x7e1f(%rip), %rax      # 0xda50
je 0x5c45
leaq 0x378a(%rip), %rdi      # 0x93c4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
jmp 0x5c66
leaq 0x3780(%rip), %rdi      # 0x93cc
xorl %eax, %eax
callq 0x4246
leaq 0x7516(%rip), %rax      # 0xd170
movq %rax, 0x7def(%rip)      # 0xda50
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: ctlxrp
int ctlxrp (int f, int n)
{
  if (kbdmip == NULL)
    {
      mlwrite ("Not now");
      return (FALSE);
    }
  mlwrite ("[End macro]");
  kbdmip = NULL;
  return (TRUE);
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x7ddd(%rip)      # 0xda50
je 0x5c95
leaq 0x375e(%rip), %rdi      # 0x93da
xorl %eax, %eax
callq 0x4246
movq $0x0, 0x7dc2(%rip) # 0xda50
movl $0x1, %ebx
jmp 0x5ca5
leaq 0x3728(%rip), %rdi      # 0x93c4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: ctlxe
int ctlxe (int f, int n)
{
  int c, af, an, s;

  if (kbdmip != NULL || kbdmop != NULL)
    {
      mlwrite ("No macro defined");
      return (FALSE);
    }
  if (n <= 0)
    return (TRUE);
  do
    {
      kbdmop = &kbdm[0];
      do
	{
	  af = FALSE;
	  an = 1;
	  if ((c = *kbdmop++) == (CTRL | 'U'))
	    {
	      af = TRUE;
	      an = *kbdmop++;
	      c = *kbdmop++;
	    }
	  s = TRUE;
	}
      while (c != (CTLX | ')') && (s = execute (c, af, an)) == TRUE);
      kbdmop = NULL;
    }
  while (s == TRUE && --n);
  return (s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x7dbc(%rip), %rax      # 0xda70
orq 0x7d95(%rip), %rax      # 0xda50
je 0x5cd2
leaq 0x3722(%rip), %rdi      # 0x93e6
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4246
jmp 0x5d6b
movl %esi, %ebx
testl %esi, %esi
jle 0x5d66
leaq 0x748d(%rip), %r14      # 0xd170
movq %r14, 0x7d86(%rip)      # 0xda70
movq 0x7d7f(%rip), %rcx      # 0xda70
leaq 0x2(%rcx), %rax
movq %rax, 0x7d74(%rip)      # 0xda70
movzwl (%rcx), %eax
cmpl $0x155, %eax            # imm = 0x155
jne 0x5d20
movswl 0x2(%rcx), %edx
leaq 0x6(%rcx), %rax
movq %rax, 0x7d5b(%rip)      # 0xda70
movzwl 0x4(%rcx), %eax
movl $0x1, %esi
jmp 0x5d27
movl $0x1, %edx
xorl %esi, %esi
movzwl %ax, %ecx
cmpl $0x429, %ecx            # imm = 0x429
je 0x5d41
movswl %ax, %edi
callq 0x5a70
cmpl $0x1, %eax
je 0x5cea
jmp 0x5d57
movq $0x0, 0x7d24(%rip) # 0xda70
movl $0x1, %ebp
decl %ebx
jne 0x5ce3
jmp 0x5d6b
movl %eax, %ebp
movq $0x0, 0x7d0c(%rip) # 0xda70
jmp 0x5d6b
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: ctrlg
int ctrlg (int f, int n)
{
  (*term.t_beep) ();
  if (kbdmip != NULL)
    {
      kbdm[0] = (CTLX | ')');
      kbdmip = NULL;
    }
  mlwrite ("[Aborted]");
  return (ABORT);
}

// Assembly:
pushq %rax
leaq 0x7aee(%rip), %rcx      # 0xd868
xorl %eax, %eax
callq *0x50(%rcx)
cmpq $0x0, 0x7cc9(%rip)      # 0xda50
je 0x5d9d
movw $0x429, 0x73de(%rip)    # imm = 0x429
movq $0x0, 0x7cb3(%rip) # 0xda50
leaq 0x3653(%rip), %rdi      # 0x93f7
xorl %eax, %eax
callq 0x4246
movl $0x2, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: extendedcmd
int extendedcmd (int f, int n)
{
  int (*cmd)();
  int c;

  c = getctl();
  switch (c)
    {
    case 'A': cmd = backline; break; /* up arrow */
    case 'B': cmd = forwline; break; /* down arrow */
    case 'C': cmd = forwchar; break; /* right arrow */
    case 'D': cmd = backchar; break; /* left arrow */
    case 'H': cmd = gotobol; break;  /* usually home */
    case 'W': cmd = gotoeol; break;  /* maybe end */
    case 'F': cmd = gotoeol; break;  /* maybe end */
    case '3': cmd = forwdel; getctl(); break; /* maybe delete */
    case '5': cmd = backpage; getctl(); break;
    case '6': cmd = forwpage; getctl(); break;
    case '7': cmd = gotobob; getctl(); break;
    case '8': cmd = gotoeob; getctl(); break;
    default: mlwrite ("\007[Key not bound]");
      return (FALSE);
    }
  return cmd(f, n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x7aa7(%rip), %r14      # 0xd868
xorl %eax, %eax
callq *0x20(%r14)
leal -0x61(%rax), %ecx
leal -0x20(%rax), %edx
cmpl $0x1a, %ecx
cmovael %eax, %edx
movl %edx, %eax
orl $0x140, %eax            # imm = 0x140
cmpl $0x20, %edx
cmovael %edx, %eax
leal -0x33(%rax), %ecx
cmpl $0x15, %ecx
ja 0x5e0a
leaq 0x3525(%rip), %rax      # 0x9314
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
xorl %eax, %eax
callq *0x20(%r14)
leaq 0x3bb(%rip), %rcx       # 0x61c0
jmp 0x5e94
cmpl $0x57, %eax
jne 0x5e18
leaq -0x3a20(%rip), %rcx     # 0x23f6
jmp 0x5e94
leaq 0x356f(%rip), %rdi      # 0x938e
xorl %eax, %eax
callq 0x4246
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x37ba(%rip), %rcx     # 0x267a
jmp 0x5e94
xorl %eax, %eax
callq *0x20(%r14)
leaq -0x37f7(%rip), %rcx     # 0x264c
jmp 0x5e94
xorl %eax, %eax
callq *0x20(%r14)
leaq -0x3753(%rip), %rcx     # 0x26ff
jmp 0x5e94
xorl %eax, %eax
callq *0x20(%r14)
leaq -0x36e6(%rip), %rcx     # 0x277b
jmp 0x5e94
leaq -0x38d0(%rip), %rcx     # 0x259a
jmp 0x5e94
xorl %eax, %eax
callq *0x20(%r14)
leaq -0x385e(%rip), %rcx     # 0x261b
jmp 0x5e94
leaq -0x3aa4(%rip), %rcx     # 0x23de
jmp 0x5e94
leaq -0x3a79(%rip), %rcx     # 0x2412
jmp 0x5e94
leaq -0x3a24(%rip), %rcx     # 0x2470
movl %ebp, %edi
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/main.c
// Function: debug
void debug(char *format, ...)
{
    char buffer[256];
    va_list args;
    va_start (args, format);

    static FILE *debug_fp = NULL;

    if (debug_fp == NULL) {
        debug_fp = fopen("debug.out","w");
    }

    vsprintf (buffer, format, args);
    va_end(args);

    fprintf(debug_fp,"%s", buffer);
    fflush(debug_fp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
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 0x5f20
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 %rdi, 0x10(%rsp)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpq $0x0, 0x7b30(%rip)      # 0xda78
jne 0x5f64
leaq 0x34cb(%rip), %rdi      # 0x941c
leaq 0x37ec(%rip), %rsi      # 0x9744
callq 0x2230
movq %rax, 0x7b14(%rip)      # 0xda78
leaq 0xd0(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq 0x7af7(%rip), %rsi      # 0xda78
movq %r14, %rdi
callq 0x2120
movq 0x7ae8(%rip), %rdi      # 0xda78
callq 0x21b0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: getccol
int getccol (int bflg)
{
  int c, i, col;

  col = 0;
  for (i = 0; i < curwp->w_doto; ++i)
    {
      c = lgetc (curwp->w_dotp, i);
      if (c != ' ' && c != '\t' && bflg)
	break;
      if (c == '\t')
	col |= 0x07;
      else if (c < 0x20 || c == 0x7F)
	++col;
      ++col;
    }
  return (col);
}

// Assembly:
leaq 0x7976(%rip), %rax      # 0xda48
movq (%rax), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
jle 0x612e
movq 0x18(%rax), %rdx
xorl %esi, %esi
xorl %eax, %eax
movzbl 0x18(%rdx,%rsi), %r8d
testl %edi, %edi
je 0x60fe
cmpl $0x9, %r8d
je 0x6104
cmpl $0x20, %r8d
je 0x6109
jmp 0x612d
cmpl $0x9, %r8d
jne 0x6109
orl $0x7, %eax
jmp 0x6123
cmpb $0x20, %r8b
setb %r9b
cmpl $0x7f, %r8d
sete %r8b
orb %r9b, %r8b
movzbl %r8b, %r8d
addl %r8d, %eax
incl %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x60e6
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: quote
int quote (int f, int n)
{
  int s, c;

  c = (*term.t_getchar) ();
  if (n < 0)
    return (FALSE);
  if (n == 0)
    return (TRUE);
  if (c == '\n')
    {
      do
	{
	  s = lnewline ();
	}
      while (s == TRUE && --n);
      return (s);
    }
  return (linsert (n, c));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
leaq 0x772b(%rip), %rcx      # 0xd868
xorl %ebp, %ebp
xorl %eax, %eax
callq *0x20(%rcx)
testl %ebx, %ebx
js 0x6170
je 0x616b
cmpl $0xa, %eax
jne 0x6179
decl %ebx
xorl %eax, %eax
callq 0x524f
movl %eax, %ebp
subl $0x1, %ebx
setb %al
cmpl $0x1, %ebp
jne 0x6170
testb %al, %al
je 0x6151
jmp 0x6170
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, %edi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5020
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: forwdel
int forwdel (int f, int n)
{
  if (n < 0)
    return (backdel (f, -n));
  if (f != FALSE)
    {			       /* Really a kill */
      if ((lastflag & CFKILL) == 0)
	kdelete ();
      thisflag |= CFKILL;
    }
  return (ldelete (n, f));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
testl %esi, %esi
js 0x61fb
testl %ebp, %ebp
je 0x61ec
leaq 0x786a(%rip), %rax      # 0xda40
testb $0x2, (%rax)
jne 0x61e2
xorl %eax, %eax
callq 0x571f
leaq 0x787f(%rip), %rax      # 0xda68
orb $0x2, (%rax)
movl %ebx, %edi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5353
negl %ebx
movl %ebp, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x620c
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: backdel
int backdel (int f, int n)
{
  int s;

  if (n < 0)
    return (forwdel (f, -n));
  if (f != FALSE)
    {			       /* Really a kill */
      if ((lastflag & CFKILL) == 0)
	kdelete ();
      thisflag |= CFKILL;
    }
  if ((s = backchar (f, n)) == TRUE)
    s = ldelete (n, f);
  return (s);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
testl %esi, %esi
js 0x6255
testl %ebp, %ebp
je 0x6238
leaq 0x781e(%rip), %rax      # 0xda40
testb $0x2, (%rax)
jne 0x622e
xorl %eax, %eax
callq 0x571f
leaq 0x7833(%rip), %rax      # 0xda68
orb $0x2, (%rax)
movl %ebp, %edi
movl %ebx, %esi
callq 0x2412
cmpl $0x1, %eax
jne 0x6266
movl %ebx, %edi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5353
negl %ebx
movl %ebp, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x61c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: killtext
int killtext (int f, int n)
{
  LINE *nextp;
  int chunk;

  if ((lastflag & CFKILL) == 0)/* Clear kill buffer if last wasn't a kill */
    kdelete ();
  thisflag |= CFKILL;
  if (f == FALSE)
    {
      chunk = llength (curwp->w_dotp) - curwp->w_doto;
      if (chunk == 0)
	chunk = 1;
    }
  else if (n == 0)
    {
      chunk = curwp->w_doto;
      curwp->w_doto = 0;
    }
  else if (n > 0)
    {
      chunk = llength (curwp->w_dotp) - curwp->w_doto + 1;
      nextp = lforw (curwp->w_dotp);
      while (--n)
	{
	  if (nextp == curbp->b_linep)
	    return (FALSE);
	  chunk += llength (nextp) + 1;
	  nextp = lforw (nextp);
	}
    }
  else
    {
      mlwrite ("neg kill");
      return (FALSE);
    }
  return (ldelete (chunk, TRUE));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leaq 0x77c5(%rip), %rax      # 0xda40
testb $0x2, (%rax)
jne 0x6287
xorl %eax, %eax
callq 0x571f
leaq 0x77da(%rip), %rax      # 0xda68
orb $0x2, (%rax)
testl %ebp, %ebp
je 0x62dc
testl %ebx, %ebx
je 0x62fa
jle 0x631f
leaq 0x77a2(%rip), %rax      # 0xda48
movq (%rax), %rcx
movq 0x18(%rcx), %rax
movl 0x14(%rax), %edi
subl 0x20(%rcx), %edi
incl %edi
decl %ebx
je 0x630f
leaq 0x7778(%rip), %rcx      # 0xda38
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
movq (%rax), %rax
cmpq %rcx, %rax
je 0x632d
movl 0x14(%rax), %edx
addl %edx, %edi
incl %edi
decl %ebx
jne 0x62c7
jmp 0x630f
leaq 0x7765(%rip), %rax      # 0xda48
movq (%rax), %rax
movq 0x18(%rax), %rcx
movl 0x14(%rcx), %ecx
subl 0x20(%rax), %ecx
movl $0x1, %edi
cmovnel %ecx, %edi
jmp 0x630f
leaq 0x7747(%rip), %rax      # 0xda48
movq (%rax), %rax
movl 0x20(%rax), %edi
movq $0x0, 0x20(%rax)
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5353
leaq 0x3133(%rip), %rdi      # 0x9459
xorl %eax, %eax
callq 0x4246
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/random.c
// Function: yank
int yank (int f, int n)
{
  int c, i;

  if (n < 0)
    return (FALSE);
  while (n--)
    {
      i = 0;
      while ((c = kremove (i)) >= 0)
	{
	  if (c == '\n')
	    {
	      if (lnewline (FALSE, 1) == FALSE)
		return (FALSE);
	    }
	  else
	    {
	      if (linsert (1, c) == FALSE)
		return (FALSE);
	    }
	  ++i;
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x6397
je 0x638f
movl %esi, %ebx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x574d
testl %eax, %eax
js 0x638b
movl $0x1, %ebp
cmpl $0xa, %eax
jne 0x636e
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x524f
testl %eax, %eax
jne 0x637e
jmp 0x639a
movl $0x1, %edi
movl %eax, %esi
callq 0x5020
testl %eax, %eax
je 0x6397
movl %ebp, %edi
callq 0x574d
incl %ebp
testl %eax, %eax
jns 0x6355
decl %ebx
jne 0x6345
movl $0x1, %r14d
jmp 0x639a
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/region.c
// Function: killregion
int killregion (int f, int n)
{
  REGION region;
  int s;

  if ((s = getregion (&region)) != TRUE)
    return (s);
  if ((lastflag & CFKILL) == 0) /* This is a kill type */
    kdelete ();			/* command, so do magic */
  thisflag |= CFKILL;		/* kill buffer stuff */
  curwp->w_dotp = region.r_linep;
  curwp->w_doto = region.r_offset;
  return (ldelete (region.r_size, TRUE));
}

// Assembly:
subq $0x18, %rsp
movq %rsp, %rdi
callq 0x6405
testl %eax, %eax
je 0x63fe
leaq 0x7685(%rip), %rax      # 0xda40
testb $0x2, (%rax)
jne 0x63c7
xorl %eax, %eax
callq 0x571f
leaq 0x769a(%rip), %rax      # 0xda68
orb $0x2, (%rax)
movq (%rsp), %rax
leaq 0x766c(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rcx)
movl 0x10(%rsp), %edi
movl $0x1, %esi
addq $0x18, %rsp
jmp 0x5353
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/region.c
// Function: getregion
int getregion (REGION *rp)
{
  LINE *flp, *blp;
  int fsize, bsize;

  if (curwp->w_markp == (struct LINE*)0)
    {
      mlwrite ("No mark set in this window");
      return (FALSE);
    }
  if (curwp->w_dotp == curwp->w_markp)
    {
      rp->r_linep = curwp->w_dotp;
      if (curwp->w_doto < curwp->w_marko)
	{
	  rp->r_offset = curwp->w_doto;
	  rp->r_size = curwp->w_marko - curwp->w_doto;
	}
      else
	{
	  rp->r_offset = curwp->w_marko;
	  rp->r_size = curwp->w_doto - curwp->w_marko;
	}
      return (TRUE);
    }
  blp = curwp->w_dotp;
  bsize = curwp->w_doto;
  flp = curwp->w_dotp;
  fsize = llength (flp) - curwp->w_doto + 1;
  while (flp != curbp->b_linep || lback (blp) != curbp->b_linep)
    {
      if (flp != curbp->b_linep)
	{
	  flp = lforw (flp);
	  if (flp == curwp->w_markp)
	    {
	      rp->r_linep = curwp->w_dotp;
	      rp->r_offset = curwp->w_doto;
	      rp->r_size = fsize + curwp->w_marko;
	      return (TRUE);
	    }
	  fsize += llength (flp) + 1;
	}
      if (lback (blp) != curbp->b_linep)
	{
	  blp = lback (blp);
	  bsize += llength (blp) + 1;
	  if (blp == curwp->w_markp)
	    {
	      rp->r_linep = blp;
	      rp->r_offset = curwp->w_marko;
	      rp->r_size = bsize - curwp->w_marko;
	      return (TRUE);
	    }
	}
    }
  mlwrite ("Bug: lost mark");
  return (FALSE);
}

// Assembly:
pushq %rbx
leaq 0x763b(%rip), %rax      # 0xda48
movq (%rax), %rsi
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x649d
movq 0x18(%rsi), %rdx
cmpq %rcx, %rdx
je 0x64c1
movl 0x20(%rsi), %esi
movl 0x14(%rdx), %r8d
subl %esi, %r8d
incl %r8d
leaq 0x75fa(%rip), %r9       # 0xda38
movq (%r9), %r9
movq 0x28(%r9), %r9
movq %rdx, %r10
movq %rdx, %r11
cmpq %r9, %r10
je 0x6468
movq (%r10), %r10
cmpq %rcx, %r10
je 0x64a6
movl 0x14(%r10), %ebx
addl %ebx, %r8d
incl %r8d
movq 0x8(%r11), %rbx
jmp 0x6471
movq 0x8(%r11), %rbx
cmpq %r9, %rbx
je 0x64e4
cmpq %r9, %rbx
je 0x644b
movl 0x14(%rbx), %r11d
addl %r11d, %esi
incl %esi
movq %rbx, %r11
cmpq %rcx, %rbx
jne 0x644b
movq %rbx, (%rdi)
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rdi)
movslq %esi, %rcx
subq %rax, %rcx
jmp 0x64bb
leaq 0x2fbe(%rip), %rdi      # 0x9462
jmp 0x64eb
movq %rdx, (%rdi)
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%rdi)
movslq %r8d, %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x64fe
movq %rdx, (%rdi)
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq 0x30(%rax), %rax
movq %rcx, %rdx
subq %rax, %rdx
jge 0x64f6
movq %rcx, 0x8(%rdi)
subq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x64fe
leaq 0x2f92(%rip), %rdi      # 0x947d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
jmp 0x6503
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq