LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x2bc7
leaq 0xdead(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x39(%rax), %eax
subl $0x2, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x2bc5
movl $0x1, -0xc(%rbp)
jmp 0x2bf9
cmpl $0x0, -0xc(%rbp)
jge 0x2be2
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x2a70
movl %eax, -0x4(%rbp)
jmp 0x2ca4
leaq 0xde6f(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x39(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2bf9
leaq 0xde58(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2c3c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xde19(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2c45
jmp 0x2c53
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2c0b
movq -0x18(%rbp), %rcx
leaq 0xddfa(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
leaq 0xdde8(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xddda(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
leaq 0xddc8(%rip), %rax      # 0x10a58
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x3b(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/basic.c
// Function: setmark
int setmark (int f, int n)
{
  curwp->w_markp = curwp->w_dotp;
  curwp->w_marko = curwp->w_doto;
  mlwrite ("[Mark set]");
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xdd93(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rcx
leaq 0xdd85(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x28(%rax)
leaq 0xdd77(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rcx
leaq 0xdd69(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x30(%rax)
leaq 0x9319(%rip), %rdi      # 0xc016
movb $0x0, %al
callq 0x56d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xda63(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x300f
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3018
jmp 0x303c
cmpq $0x0, -0x10(%rbp)
jne 0x302f
leaq 0xdb1a(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x303a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2fef
movq -0x10(%rbp), %rdi
callq 0x2d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0xd9dc(%rip), %rax      # 0x10a48
movq (%rax), %rdx
addq $0x83, %rdx
leaq 0x8fa4(%rip), %rsi      # 0xc021
movb $0x0, %al
callq 0x2270
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x5d40
movl %eax, -0x84(%rbp)
cmpl $0x2, -0x84(%rbp)
jne 0x30b1
movl $0x2, -0x4(%rbp)
jmp 0x31a6
cmpl $0x0, -0x84(%rbp)
jne 0x30ca
leaq 0xd987(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x30ef
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x31c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x30ed
movl $0x0, -0x4(%rbp)
jmp 0x31a6
jmp 0x30ef
jmp 0x30f1
movq -0x18(%rbp), %rax
leaq 0xd96c(%rip), %rcx      # 0x10a68
cmpq (%rcx), %rax
jne 0x3120
leaq 0xd770(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x50(%rcx)
movb $0x0, %al
callq 0x4260
movl $0x0, -0x4(%rbp)
jmp 0x31a6
leaq 0xda19(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x315e
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x3151
movq -0x20(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x3151
jmp 0x315e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x312e
cmpq $0x0, -0x20(%rbp)
jne 0x316e
callq 0x3400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x317e
movl $0x0, -0x4(%rbp)
jmp 0x31a6
movq -0x20(%rbp), %rdi
callq 0x2d50
movq -0x18(%rbp), %rdi
callq 0x3460
movl %eax, -0x84(%rbp)
movb $0x0, %al
callq 0x4260
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/buffer.c
// Function: get_scratch
BUFFER* get_scratch(void)
{
  BUFFER* bp;

  bp = bfind("*scratch*", FALSE, 0);

  if (bp != NULL)
	return bp;

  /* create scratch */
  bp = bfind("*scratch*", TRUE, 0);
  return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8c2d(%rip), %rdi      # 0xc03c
xorl %edx, %edx
movl %edx, %esi
callq 0x31c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x342d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x344c
leaq 0x8c08(%rip), %rdi      # 0xc03c
movl $0x1, %esi
xorl %edx, %edx
callq 0x31c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x31(%rax), %eax
cmpl $0x0, %eax
je 0x3485
movl $0x0, -0x4(%rbp)
jmp 0x351d
movq -0x10(%rbp), %rdi
callq 0x3530
movl %eax, -0x24(%rbp)
cmpl $0x1, %eax
je 0x349e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x351d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq $0x0, -0x18(%rbp)
leaq 0xd686(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x34e0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x34c1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3502
movq -0x20(%rbp), %rcx
leaq 0xd643(%rip), %rax      # 0x10b40
movq %rcx, (%rax)
jmp 0x350d
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3578
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3578
leaq 0x8b44(%rip), %rdi      # 0xc0a7
callq 0x5620
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
je 0x3578
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35e5
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %ecx
andl $-0x3, %ecx
movb %cl, 0x32(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
je 0x35aa
movq -0x18(%rbp), %rdi
callq 0x6b80
jmp 0x3586
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x3780
movl %eax, -0x24(%rbp)
cmpl $0x1, %eax
je 0x3616
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3777
leaq 0xd44b(%rip), %rax      # 0x10a68
movq (%rax), %rax
movsbl 0x31(%rax), %eax
cmpl $0x0, %eax
jne 0x36cf
movb $0x0, %al
callq 0xb640
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x364a
movl $0x0, -0x4(%rbp)
jmp 0x3777
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movb 0x31(%rcx), %al
addb $-0x1, %al
movb %al, 0x31(%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x36aa
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0xd3b7(%rip), %rax      # 0x10a68
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xd3a5(%rip), %rax      # 0x10a68
movq (%rax), %rax
movb 0x31(%rax), %cl
addb $0x1, %cl
movb %cl, 0x31(%rax)
leaq 0xd39a(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3770
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xd371(%rip), %rcx      # 0x10a68
cmpq (%rcx), %rax
jne 0x3760
leaq 0xd365(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0xd34c(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl $0x18, %ecx
movb %cl, 0x3b(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x36dd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movb $0x0, %al
callq 0x6b00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3b68
movl $0x0, -0x4(%rbp)
jmp 0x3c2e
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3b99
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, 0x18(%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3b6f
movq -0x18(%rbp), %rcx
leaq 0xcec4(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
leaq 0xceaf(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
leaq 0xce91(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0xce7f(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq 0xce6a(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq 0x8(%rax), %rax
leaq 0xce5c(%rip), %rcx      # 0x10a68
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x3c27
movq -0x18(%rbp), %rcx
leaq 0xce48(%rip), %rax      # 0x10a68
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0xa, -0x10(%rbp)
jl 0x3c91
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
jmp 0x3c5a
movl -0x10(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
je 0x3cc8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
jmp 0x3cac
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/buffer.c
// Function: anycb
int anycb ()
{
  BUFFER *bp;

  bp = bheadp;
  while (bp != NULL)
    {
      if ((bp->b_flag & BFTEMP) == 0 && (bp->b_flag & BFCHG) != 0)
	return (TRUE);
      bp = bp->b_bufp;
    }
  return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xce65(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3d1f
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3d12
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3d12
movl $0x1, -0x4(%rbp)
jmp 0x3d26
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3ce2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/bufmenu.c
// Function: count_buffers
int count_buffers(void)
{
	BUFFER *bp;
	int count = 0;

	bp = bheadp;
	while (bp != NULL)
	{
		if ((bp->b_flag & BFTEMP) != 0)
		{
			bp = bp->b_bufp;
			continue;
		}
		count++;
		bp = bp->b_bufp;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
leaq 0xca6e(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4113
movq -0x8(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x40fd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x40d9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x40d9
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/bufmenu.c
// Function: get_buffer
BUFFER *get_buffer(int n)
{
	BUFFER *bp;
	int i = 0;

	bp = bheadp;
	while (bp != NULL)
	{
		if ((bp->b_flag & BFTEMP) != 0)
		{
			bp = bp->b_bufp;
			continue;
		}
	 
		if (++i == n)
			return bp;

		bp = bp->b_bufp;
	}

	/* we should never get here */
	mlwrite("[Fatal: could not find buffer]");
	exit(1);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0xca07(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4189
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4164
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl -0x4(%rbp), %eax
jne 0x417c
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4140
leaq 0x810e(%rip), %rdi      # 0xc29e
movb $0x0, %al
callq 0x56d0
movl $0x1, %edi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/bufmenu.c
// Function: valid_buf
int valid_buf(BUFFER* bp_try)
{
	BUFFER *bp;

	bp = bheadp;
	while (bp != NULL)
	{
		if (bp == bp_try)
			return TRUE;  /* we found it */
		bp = bp->b_bufp;
	}

	/* if we get here the buffer must have been killed */
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0xc981(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x41ed
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x41e0
movl $0x1, -0x4(%rbp)
jmp 0x41f4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x41c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xbf59(%rip), %eax      # 0x10170
jne 0x4224
movl -0x8(%rbp), %eax
cmpl 0xbf52(%rip), %eax      # 0x10174
je 0x424b
movl -0x4(%rbp), %eax
movl %eax, 0xbf43(%rip)      # 0x10170
movl -0x8(%rbp), %eax
movl %eax, 0xbf3e(%rip)      # 0x10174
leaq 0xc63b(%rip), %rax      # 0x10878
movq 0x38(%rax), %rcx
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movb $0x0, %al
callq *%rcx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc609(%rip), %rax      # 0x10878
movl (%rax), %edi
xorl %esi, %esi
callq 0x4200
leaq 0xc101(%rip), %rax      # 0x10380
cmpl $0x1, (%rax)
jne 0x4292
leaq 0xc5ed(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x40(%rcx)
jmp 0x42ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0xc5d5(%rip), %rcx      # 0x10878
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x42c9
movl $0x20, %edi
leaq 0xc5bf(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x28(%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4299
leaq 0xc5a8(%rip), %rax      # 0x10878
movl (%rax), %edi
movl $0x1, %esi
callq 0x4200
leaq 0xc595(%rip), %rax      # 0x10878
movl (%rax), %edi
xorl %esi, %esi
callq 0x4200
leaq 0xc585(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x30(%rcx)
leaq 0xc745(%rip), %rax      # 0x10a44
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc559(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x10(%rcx)
xorl %edi, %edi
leaq 0xc54b(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x58(%rcx)
leaq 0xc53f(%rip), %rax      # 0x10878
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, 0xc5c4(%rip)      # 0x10910
cmpq $0x0, 0xc5bc(%rip)      # 0x10910
jne 0x4360
movl $0x1, %edi
callq 0x2280
leaq 0xc511(%rip), %rax      # 0x10878
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, 0xc59e(%rip)      # 0x10918
cmpq $0x0, 0xc596(%rip)      # 0x10918
jne 0x438e
movl $0x1, %edi
callq 0x2280
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xc4d9(%rip), %rcx      # 0x10878
cmpl (%rcx), %eax
jge 0x443f
leaq 0xc4ca(%rip), %rax      # 0x10878
movslq 0x4(%rax), %rdi
addq $0x4, %rdi
callq 0x21c0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x43d0
movl $0x1, %edi
callq 0x2280
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rdx
movq 0xc52c(%rip), %rax      # 0x10910
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
leaq 0xc485(%rip), %rax      # 0x10878
movslq 0x4(%rax), %rdi
addq $0x4, %rdi
callq 0x21c0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4415
movl $0x1, %edi
callq 0x2280
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rdx
movq 0xc4ef(%rip), %rax      # 0x10918
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4395
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xc45e(%rip), %rax      # 0x10910
movslq 0xc447(%rip), %rcx      # 0x10900
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl 0xc43d(%rip), %eax      # 0x10904
leaq 0xc3aa(%rip), %rcx      # 0x10878
cmpl 0x4(%rcx), %eax
jl 0x4500
movl 0xc42b(%rip), %eax      # 0x10904
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, 0xc41f(%rip)      # 0x10904
movq -0x10(%rbp), %rax
leaq 0xc388(%rip), %rcx      # 0x10878
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x24, 0x2(%rax,%rcx)
jmp 0x456a
cmpl $0x9, -0x4(%rbp)
jne 0x4522
jmp 0x4508
movl $0x20, %edi
callq 0x44a0
movl 0xc3ec(%rip), %eax      # 0x10904
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x4508
jmp 0x4568
cmpl $0x20, -0x4(%rbp)
jl 0x452e
cmpl $0x7f, -0x4(%rbp)
jne 0x4545
movl $0x5e, %edi
callq 0x44a0
movl -0x4(%rbp), %edi
xorl $0x40, %edi
callq 0x44a0
jmp 0x4566
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl 0xc3b0(%rip), %ecx      # 0x10904
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc3a5(%rip)      # 0x10904
movslq %ecx, %rcx
movb %dl, 0x2(%rax,%rcx)
jmp 0x4568
jmp 0x456a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xc38e(%rip), %rax      # 0x10910
movslq 0xc377(%rip), %rcx      # 0x10900
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl 0xc36d(%rip), %eax      # 0x10904
leaq 0xc2da(%rip), %rcx      # 0x10878
cmpl 0x4(%rcx), %eax
jl 0x45d0
movl 0xc35b(%rip), %eax      # 0x10904
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, 0xc34f(%rip)      # 0x10904
movq -0x10(%rbp), %rax
leaq 0xc2b8(%rip), %rcx      # 0x10878
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x24, 0x2(%rax,%rcx)
jmp 0x464b
cmpl $0x9, -0x4(%rbp)
jne 0x45f8
jmp 0x45d8
movl $0x20, %edi
callq 0x4570
movl 0xc31c(%rip), %eax      # 0x10904
addl 0xc31a(%rip), %eax      # 0x10908
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x45d8
jmp 0x4649
cmpl $0x20, -0x4(%rbp)
jl 0x4604
cmpl $0x7f, -0x4(%rbp)
jne 0x461b
movl $0x5e, %edi
callq 0x4570
movl -0x4(%rbp), %edi
xorl $0x40, %edi
callq 0x4570
jmp 0x4647
cmpl $0x0, 0xc2e2(%rip)      # 0x10904
jl 0x4638
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq 0xc2d0(%rip), %rcx      # 0x10904
movb %dl, 0x2(%rax,%rcx)
movl 0xc2c6(%rip), %eax      # 0x10904
addl $0x1, %eax
movl %eax, 0xc2bd(%rip)      # 0x10904
jmp 0x4649
jmp 0x464b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/display.c
// Function: vteeol
void vteeol ()
{
  VIDEO *vp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xc2a5(%rip), %rax      # 0x10910
movslq 0xc28e(%rip), %rcx      # 0x10900
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movl 0xc284(%rip), %eax      # 0x10904
leaq 0xc1f1(%rip), %rcx      # 0x10878
cmpl 0x4(%rcx), %eax
jge 0x46ab
movq -0x8(%rbp), %rax
movl 0xc26e(%rip), %ecx      # 0x10904
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xc263(%rip)      # 0x10904
movslq %ecx, %rcx
movb $0x20, 0x2(%rax,%rcx)
jmp 0x467a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb615(%rip), %rax      # 0x10b34
movl (%rax), %eax
leaq 0xb350(%rip), %rcx      # 0x10878
subl 0x4(%rcx), %eax
leaq 0xb346(%rip), %rcx      # 0x10878
cltd
idivl 0xc(%rcx)
leaq 0xb33b(%rip), %rax      # 0x10878
addl 0x8(%rax), %edx
movl %edx, -0xc(%rbp)
leaq 0xb5ea(%rip), %rax      # 0x10b34
movl (%rax), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, 0xb3b0(%rip)      # 0x10908
leaq 0xb5d1(%rip), %rax      # 0x10b30
movl (%rax), %edi
xorl %esi, %esi
subl 0xb39f(%rip), %esi      # 0x10908
callq 0x4480
leaq 0xb4e3(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x55b6
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %edi
andl $0xff, %edi
callq 0x4570
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5587
callq 0x4660
movq 0xb34e(%rip), %rax      # 0x10910
leaq 0xb567(%rip), %rcx      # 0x10b30
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movb $0x24, 0x2(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/display.c
// Function: upmode
void upmode ()
{
  WINDOW *wp;

  wp = wheadp;
  while (wp != NULL)
    {
      wp->w_flag |= WFMODE;
      wp = wp->w_wndp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb485(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5614
movq -0x8(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x3b(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x55f2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3c, %edx
callq 0x2070
leaq -0x70(%rbp), %rdi
leaq 0x6c7e(%rip), %rsi      # 0xc2c7
movl $0x9, %edx
callq 0x2150
leaq -0x70(%rbp), %rdi
movb $0x0, %al
callq 0x56d0
leaq 0xb213(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x20(%rcx)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x7, %eax
jne 0x567f
movl $0x2, -0x4(%rbp)
jmp 0x56ba
movsbl -0x11(%rbp), %eax
cmpl $0x79, %eax
je 0x5691
movsbl -0x11(%rbp), %eax
cmpl $0x59, %eax
jne 0x569a
movl $0x1, -0x4(%rbp)
jmp 0x56ba
movsbl -0x11(%rbp), %eax
cmpl $0x6e, %eax
je 0x56ac
movsbl -0x11(%rbp), %eax
cmpl $0x4e, %eax
jne 0x56b5
movl $0x0, -0x4(%rbp)
jmp 0x56ba
jmp 0x562c
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5705
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq 0xb1c1(%rip), %rdi      # 0x10920
callq 0x2220
leaq -0x20(%rbp), %rax
leaq 0xac11(%rip), %rax      # 0x10380
cmpl $0x0, (%rax)
jne 0x5785
callq 0x4260
leaq 0xb0f8(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x30(%rcx)
leaq 0xb0ec(%rip), %rax      # 0x10878
movl (%rax), %edi
xorl %esi, %esi
callq 0x4200
leaq 0xb184(%rip), %rdi      # 0x10920
callq 0x5d70
leaq 0xabd8(%rip), %rax      # 0x10380
cmpl $0x1, (%rax)
jne 0x57b9
leaq 0xb0c4(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x40(%rcx)
leaq 0xb0b8(%rip), %rax      # 0x10878
movq 0x30(%rax), %rcx
xorl %eax, %eax
callq *%rcx
leaq 0xb275(%rip), %rax      # 0x10a44
movl $0x1, (%rax)
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/display.c
// Function: mlputs
void mlputs (char *s)
{
  int c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x5db9
leaq 0xaadb(%rip), %rax      # 0x10878
movq 0x28(%rax), %rcx
movl -0xc(%rbp), %edi
movb $0x0, %al
callq *%rcx
movl 0xa3c6(%rip), %eax      # 0x10174
addl $0x1, %eax
movl %eax, 0xa3bd(%rip)      # 0x10174
jmp 0x5d7c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/file.c
// Function: viewfile
int viewfile (int f, int n)
{
  char fname[NFILEN];		/* file user wishes to find */
  int s;			/* status return */

  if ((s = getfilename("View File: ", fname, NFILEN)) != TRUE)
    return (s);

  if ( (s = (getfile (fname))) == TRUE)
	togglereadonly(f,n);
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x60(%rbp), %rsi
leaq 0x6193(%rip), %rdi      # 0xc2dc
movl $0x50, %edx
callq 0xb6d0
movl %eax, -0x64(%rbp)
cmpl $0x1, %eax
je 0x6163
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6185
leaq -0x60(%rbp), %rdi
callq 0x5e10
movl %eax, -0x64(%rbp)
cmpl $0x1, %eax
jne 0x617f
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x2d10
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x61be
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x61a4
jmp 0x61c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
je 0x61e3
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x61ec
jmp 0x61fa
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x61c0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
addq $0xf, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x22(%rbp)
je 0x6239
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x6239
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x6242
jmp 0x6266
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x6202
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x70(%rbp), %rsi
leaq 0x5dba(%rip), %rdi      # 0xc376
movl $0x50, %edx
callq 0x5d40
movl %eax, -0x74(%rbp)
cmpl $0x1, %eax
je 0x65d9
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6666
leaq -0x70(%rbp), %rdi
callq 0x6680
movl %eax, -0x74(%rbp)
cmpl $0x1, %eax
jne 0x6660
leaq 0xa457(%rip), %rax      # 0x10a48
movq (%rax), %rdi
addq $0x33, %rdi
leaq -0x70(%rbp), %rsi
movl $0x50, %edx
callq 0x2070
leaq 0xa43b(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x32(%rax), %ecx
andl $-0x3, %ecx
movb %cl, 0x32(%rax)
leaq 0xa44f(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x665e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xa40a(%rip), %rcx      # 0x10a48
cmpq (%rcx), %rax
jne 0x6651
movq -0x18(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x3b(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6628
jmp 0x6660
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68c0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x66a9
movl $0x0, -0x4(%rbp)
jmp 0x6779
leaq 0x5ce0(%rip), %rdi      # 0xc390
movb $0x0, %al
callq 0x56d0
leaq 0xa38a(%rip), %rax      # 0x10a48
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
leaq 0xa36a(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
je 0x671b
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x6950
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x6705
jmp 0x671b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x66d3
cmpl $0x0, -0x20(%rbp)
jne 0x675c
movb $0x0, %al
callq 0x6910
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x675a
cmpl $0x1, -0x1c(%rbp)
jne 0x6747
leaq 0x5c5c(%rip), %rdi      # 0xc39a
movb $0x0, %al
callq 0x56d0
jmp 0x6758
movl -0x1c(%rbp), %esi
leaq 0x5c58(%rip), %rdi      # 0xc3a9
movb $0x0, %al
callq 0x56d0
jmp 0x675a
jmp 0x6763
movb $0x0, %al
callq 0x6910
cmpl $0x0, -0x20(%rbp)
je 0x6772
movl $0x0, -0x4(%rbp)
jmp 0x6779
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xa2a3(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x67c0
movl $0x1, -0x4(%rbp)
jmp 0x6865
leaq 0xa281(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x33(%rax), %eax
cmpl $0x0, %eax
jne 0x67ea
leaq 0x5ba9(%rip), %rdi      # 0xc383
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x6865
leaq 0xa257(%rip), %rax      # 0x10a48
movq (%rax), %rdi
addq $0x33, %rdi
callq 0x6680
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
jne 0x685f
leaq 0xa23c(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x32(%rax), %ecx
andl $-0x3, %ecx
movb %cl, 0x32(%rax)
leaq 0xa250(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x685d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xa20b(%rip), %rcx      # 0x10a48
cmpq (%rcx), %rax
jne 0x6850
movq -0x18(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x3b(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6827
jmp 0x685f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/fileio.c
// Function: ffwopen
int ffwopen (char *fn)
{
  if ((ffp = fopen (fn, "w")) == NULL)
    {
      mlwrite ("Cannot open file for writing");
      return (FIOERR);
    }
  return (FIOSUC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5fd9(%rip), %rsi      # 0xc8b0
callq 0x2250
movq %rax, 0xa13d(%rip)      # 0x10a20
cmpq $0x0, %rax
jne 0x6900
leaq 0x5aca(%rip), %rdi      # 0xc3ba
movb $0x0, %al
callq 0x56d0
movl $0x3, -0x4(%rbp)
jmp 0x6907
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/fileio.c
// Function: ffclose
int ffclose ()
{
  if (fclose (ffp) != FALSE)
    {
      mlwrite ("Error closing file");
      return (FIOERR);
    }
  return (FIOSUC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xa101(%rip), %rdi      # 0x10a20
callq 0x20c0
cmpl $0x0, %eax
je 0x6940
leaq 0x5aa7(%rip), %rdi      # 0xc3d7
movb $0x0, %al
callq 0x56d0
movl $0x3, -0x4(%rbp)
jmp 0x6947
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6997
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
andl $0xff, %edi
movq 0xa099(%rip), %rsi      # 0x10a20
callq 0x2170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6966
movq 0xa082(%rip), %rsi      # 0x10a20
movl $0xa, %edi
callq 0x2170
movq 0xa071(%rip), %rdi      # 0x10a20
callq 0x20a0
cmpl $0x0, %eax
je 0x69d0
leaq 0x5a2a(%rip), %rdi      # 0xc3ea
movb $0x0, %al
callq 0x56d0
movl $0x3, -0x4(%rbp)
jmp 0x69d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0xa023(%rip), %rdi      # 0x10a20
callq 0x2160
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x1d(%rbp)
je 0x6a1b
cmpl $0xa, -0x18(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x6a24
jmp 0x6a90
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jl 0x6a71
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
leaq 0x599c(%rip), %rdi      # 0xc3fa
movb $0x0, %al
callq 0x56d0
movl $0x4, -0x4(%rbp)
jmp 0x6af7
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x69f6
cmpl $-0x1, -0x18(%rbp)
jne 0x6ae4
movq 0x9f83(%rip), %rdi      # 0x10a20
callq 0x20a0
cmpl $0x0, %eax
je 0x6abe
leaq 0x595f(%rip), %rdi      # 0xc40d
movb $0x0, %al
callq 0x56d0
movl $0x3, -0x4(%rbp)
jmp 0x6af7
cmpl $0x0, -0x1c(%rbp)
je 0x6adb
leaq 0x5952(%rip), %rdi      # 0xc41d
movb $0x0, %al
callq 0x56d0
movl $0x3, -0x4(%rbp)
jmp 0x6af7
movl $0x2, -0x4(%rbp)
jmp 0x6af7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq