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

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

// Assembly:
pushq %rax
testl %edi, %edi
je 0x27a0
testl %esi, %esi
js 0x27ff
leaq 0xb2b4(%rip), %rax      # 0xda48
movq (%rax), %rax
movsbl 0x39(%rax), %eax
imull %esi, %eax
jmp 0x27be
leaq 0xb2a1(%rip), %rax      # 0xda48
movq (%rax), %rax
movzbl 0x39(%rax), %eax
cmpb $0x4, %al
movl $0x3, %ecx
cmovgel %eax, %ecx
movzbl %cl, %eax
addl $-0x2, %eax
leaq 0xb283(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq 0x10(%rcx), %rdi
leaq 0xb265(%rip), %rdx      # 0xda38
movq (%rdx), %rdx
incl %eax
movq %rdi, %rsi
decl %eax
je 0x27e9
movq 0x8(%rsi), %rdi
cmpq 0x28(%rdx), %rdi
jne 0x27d8
movq %rsi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
orb $0x8, 0x3b(%rcx)
jmp 0x2806
negl %esi
callq 0x26ff
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: swbuffer
int swbuffer (BUFFER *bp)
{
  WINDOW *wp;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb1d1(%rip), %r14      # 0xda38
movq (%r14), %rax
decb 0x31(%rax)
jne 0x2899
leaq 0xb1d2(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq %rbx, (%r14)
cmpb $0x1, 0x30(%rbx)
je 0x28c5
leaq 0x33(%rbx), %rdi
callq 0x4b54
movq (%r14), %rax
movq 0x28(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x1, 0x30(%rax)
leaq 0xb17c(%rip), %rax      # 0xda48
movq (%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
orb $0x19, 0x3b(%rax)
movb 0x31(%rbx), %cl
leal 0x1(%rcx), %edx
movb %dl, 0x31(%rbx)
testb %cl, %cl
je 0x2927
leaq 0xb16d(%rip), %rcx      # 0xda60
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x294a
cmpq %rax, %rcx
je 0x28f3
cmpq %rbx, 0x8(%rcx)
jne 0x28f3
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x28(%rax)
addq $0x30, %rcx
movq %rcx, %rbx
jmp 0x2943
movq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rbx
movq (%rbx), %rcx
movq %rcx, 0x30(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: killbuffer
int killbuffer (int f, int n)
{
  BUFFER *bp;
  BUFFER *bp_alt;
  char bufn[NBUFN];
  char prompt[NFILEN];
  int s;

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0xb0a0(%rip), %r14      # 0xda38
movl $0x83, %edx
addq (%r14), %rdx
leaq 0x667a(%rip), %rsi      # 0x9021
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2250
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x4884
movl %eax, %ebp
cmpl $0x2, %eax
je 0x2a4b
testl %ebp, %ebp
jne 0x29d6
movq (%r14), %rbx
jmp 0x29ec
movq %rsp, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a56
movq %rax, %rbx
testq %rax, %rax
je 0x2a4b
leaq 0xb065(%rip), %rax      # 0xda58
cmpq (%rax), %rbx
je 0x2a32
leaq 0xb131(%rip), %rax      # 0xdb30
movq (%rax), %rax
testq %rax, %rax
je 0x2a14
cmpq %rbx, %rax
je 0x29ff
testb $0x1, 0x32(%rax)
jne 0x29ff
jmp 0x2a19
callq 0x2b6f
testq %rax, %rax
je 0x2a49
movq %rax, %rdi
callq 0x2859
movq %rbx, %rdi
callq 0x2b9b
movl %eax, %ebp
jmp 0x2a40
leaq 0xae2f(%rip), %rcx      # 0xd868
xorl %ebp, %ebp
xorl %eax, %eax
callq *0x50(%rcx)
xorl %eax, %eax
callq 0x33c8
jmp 0x2a4b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: bfind
BUFFER* bfind (char *bname, int cflag, int bflag)
{
  BUFFER *bp, *sb;
  LINE *lp;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xb0c0(%rip), %rbx      # 0xdb30
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2aaa
leaq 0x83(%rbx), %rsi
movq %r14, %rdi
callq 0x2170
testl %eax, %eax
jne 0x2a70
testb $0x1, 0x32(%rbx)
je 0x2b5d
leaq 0x65ee(%rip), %rdi      # 0x908a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x43cc
jmp 0x2b5d
testl %r15d, %r15d
je 0x2b5b
movl $0x98, %edi
callq 0x21a0
testq %rax, %rax
je 0x2b5b
movq %rax, %rbx
xorl %edi, %edi
xorl %eax, %eax
callq 0x503c
testq %rax, %rax
je 0x2b53
movq %rax, %r15
leaq 0xb04f(%rip), %r13      # 0xdb30
movq (%r13), %r12
testq %r12, %r12
je 0x2b07
leaq 0x83(%r12), %rdi
movq %r14, %rsi
callq 0x2170
testl %eax, %eax
jg 0x2b07
movq %r12, %r13
movq (%r12), %r12
jmp 0x2ae5
movq %r12, (%rbx)
movq %rbx, (%r13)
movw $0x1, 0x30(%rbx)
movq %r15, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movb %bpl, 0x32(%rbx)
movq %r15, 0x28(%rbx)
movb $0x0, 0x33(%rbx)
movq %rbx, %rdi
addq $0x83, %rdi
movl $0x10, %edx
movq %r14, %rsi
callq 0x2070
movq %r15, (%r15)
movq %r15, 0x8(%r15)
jmp 0x2b5d
movq %rbx, %rdi
callq 0x2040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: zotbuf
int zotbuf (BUFFER *bp)
{
  BUFFER *bp1, *bp2;
  int s;

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

// Assembly:
xorl %eax, %eax
cmpb $0x0, 0x31(%rdi)
je 0x2ba4
retq
pushq %rbx
movq %rdi, %rbx
callq 0x2bf3
cmpl $0x1, %eax
jne 0x2bf1
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0xaf6e(%rip), %rdx      # 0xdb30
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2bc4
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2be1
leaq 0xaf4f(%rip), %rax      # 0xdb30
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2040
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: bclear
int bclear (BUFFER *bp)
{
  LINE *lp;
  int s;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x32(%rdi), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x2c11
leaq 0x64a0(%rip), %rdi      # 0x90a7
callq 0x4344
cmpl $0x1, %eax
jne 0x2c40
andb $-0x3, 0x32(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
cmpq %rax, %rdi
je 0x2c28
callq 0x508c
jmp 0x2c15
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: listbuffers
int listbuffers (int f, int n)
{
  WINDOW *wp;
  BUFFER *bp;
  int s;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2cf8
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x2cee
leaq 0xadfb(%rip), %r14      # 0xda58
movq (%r14), %rax
cmpb $0x0, 0x31(%rax)
jne 0x2ca7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x7f3d
testq %rax, %rax
je 0x2cee
movq 0x8(%rax), %rcx
decb 0x31(%rcx)
jne 0x2c9d
movq 0x18(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rdx
movq %rdx, 0x10(%rcx)
movq 0x28(%rax), %rdx
movq %rdx, 0x18(%rcx)
movq 0x30(%rax), %rdx
movq %rdx, 0x20(%rcx)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
incb 0x31(%rcx)
leaq 0xadb2(%rip), %rax      # 0xda60
movq (%rax), %rax
movl $0x1, %ebx
testq %rax, %rax
je 0x2cee
movq (%r14), %rcx
xorps %xmm0, %xmm0
cmpq %rcx, 0x8(%rax)
jne 0x2ce6
movq 0x28(%rcx), %rdx
movq (%rdx), %rdx
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
orb $0x18, 0x3b(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x2cc1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/buffer.c
// Function: addline
int addline (char *text)
{
  LINE *lp;
  int ntext, i;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r14
xorl %ebp, %ebp
movl %r14d, %edi
xorl %eax, %eax
callq 0x503c
testq %rax, %rax
je 0x2f58
testl %r14d, %r14d
jle 0x2f17
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, 0x18(%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x2f08
leaq 0xab3a(%rip), %rcx      # 0xda58
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq (%rcx), %rdx
movq 0x28(%rdx), %rdx
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
movl $0x1, %ebp
cmpq 0x28(%rcx), %rdx
jne 0x2f58
movq %rax, 0x8(%rcx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq %esi, %rax
movb $0x0, (%rdi,%rax)
cmpl $0xa, %edx
jl 0x2fa4
addq %rdi, %rax
decq %rax
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
movl %edx, %ecx
imulq %r8, %rcx
shrq $0x23, %rcx
leal (%rcx,%rcx), %r9d
leal (%r9,%r9,4), %r9d
movl %edx, %r10d
subl %r9d, %r10d
orb $0x30, %r10b
movb %r10b, (%rax)
decl %esi
decq %rax
cmpl $0x63, %edx
movl %ecx, %edx
ja 0x2f77
jmp 0x2fa6
movl %edx, %ecx
addb $0x30, %cl
movslq %esi, %rax
movb %cl, -0x1(%rdi,%rax)
decq %rax
testl %eax, %eax
je 0x2fcf
addl $-0x2, %esi
movslq %esi, %rcx
subq %rsi, %rcx
addq %rcx, %rdi
movl %eax, %edx
movl $0x20, %esi
jmp 0x2130
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/display.c
// Function: movecursor
void movecursor (int row, int col)
{
  if (row != ttrow || col != ttcol)
    {
      ttrow = row;
      ttcol = col;
      (*term.t_move) (row, col);
    }
}

// Assembly:
cmpl %edi, 0x9dbe(%rip)      # 0xd160
jne 0x33ad
cmpl %esi, 0x9dba(%rip)      # 0xd164
jne 0x33ad
retq
movl %edi, 0x9dad(%rip)      # 0xd160
movl %esi, 0x9dab(%rip)      # 0xd164
leaq 0xa4a8(%rip), %rax      # 0xd868
movq 0x38(%rax), %rcx
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/display.c
// Function: mlerase
void mlerase ()
{
  int i;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xa496(%rip), %rbx      # 0xd868
movl (%rbx), %edi
cmpl %edi, 0x9d86(%rip)      # 0xd160
jne 0x33e5
cmpl $0x0, 0x9d81(%rip)      # 0xd164
je 0x33fc
movl %edi, 0x9d75(%rip)      # 0xd160
movl $0x0, 0x9d6f(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%rbx)
leaq 0x9f6d(%rip), %rax      # 0xd370
cmpl $0x1, (%rax)
jne 0x340f
xorl %eax, %eax
callq *0x40(%rbx)
jmp 0x3483
cmpl $0x2, 0x4(%rbx)
jl 0x342c
xorl %ebp, %ebp
movl $0x20, %edi
xorl %eax, %eax
callq *0x28(%rbx)
incl %ebp
movl 0x4(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jl 0x3417
movl (%rbx), %edi
cmpl %edi, 0x9d2c(%rip)      # 0xd160
jne 0x343f
cmpl $0x1, 0x9d27(%rip)      # 0xd164
je 0x3459
movl %edi, 0x9d1b(%rip)      # 0xd160
movl $0x1, 0x9d15(%rip)      # 0xd164
movl $0x1, %esi
xorl %eax, %eax
callq *0x38(%rbx)
movl (%rbx), %edi
cmpl %edi, 0x9cff(%rip)      # 0xd160
jne 0x346c
cmpl $0x0, 0x9cfa(%rip)      # 0xd164
je 0x3483
movl %edi, 0x9cee(%rip)      # 0xd160
movl $0x0, 0x9ce8(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%rbx)
xorl %eax, %eax
callq *0x30(%rbx)
leaq 0xa5a5(%rip), %rax      # 0xda34
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/display.c
// Function: vtinit
void vtinit ()
{
  VIDEO *vp;
  //char *malloc ();
  int i;

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xa3c0(%rip), %r15      # 0xd868
xorl %eax, %eax
callq *0x10(%r15)
xorl %edi, %edi
xorl %eax, %eax
callq *0x58(%r15)
movslq (%r15), %r14
leaq (,%r14,8), %rbx
movq %rbx, %rdi
callq 0x21a0
movq %rax, 0xa430(%rip)      # 0xd900
testq %rax, %rax
je 0x3541
movq %rbx, %rdi
callq 0x21a0
movq %rax, 0xa424(%rip)      # 0xd908
testq %rax, %rax
je 0x3541
testl %r14d, %r14d
jle 0x353b
movslq 0x4(%r15), %rbx
addq $0x4, %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x3541
movw $0x0, (%rax)
movq 0xa3ee(%rip), %rcx      # 0xd900
movq %rax, (%rcx,%r15,8)
movq %rbx, %rdi
callq 0x21a0
testq %rax, %rax
je 0x3541
movw $0x0, (%rax)
movq 0xa3d9(%rip), %rcx      # 0xd908
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x34f9
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O1/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
movl %edi, %ebx
leaq 0xa2c0(%rip), %r14      # 0xd868
movq 0xa351(%rip), %rax      # 0xd900
movslq 0xa33a(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rax
movslq 0xa333(%rip), %rcx      # 0xd8f4
movslq 0x4(%r14), %rdx
cmpl %edx, %ecx
jge 0x3604
cmpl $0x9, %ebx
je 0x35ef
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x3617
movl $0x5e, %edi
callq 0x359b
xorl $0x40, %ebx
jmp 0x35a8
movl $0x20, %edi
callq 0x359b
testb $0x7, 0xa2f4(%rip)      # 0xd8f4
jne 0x35ef
jmp 0x3624
addl $0x7, %ecx
andl $-0x8, %ecx
movl %ecx, 0xa2e4(%rip)      # 0xd8f4
movb $0x24, 0x1(%rdx,%rax)
jmp 0x3624
leal 0x1(%rcx), %edx
movl %edx, 0xa2d4(%rip)      # 0xd8f4
movb %bl, 0x2(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edi, %ebx
leaq 0xa22f(%rip), %r14      # 0xd868
movq 0xa2c0(%rip), %rax      # 0xd900
movslq 0xa2a9(%rip), %rcx      # 0xd8f0
movq (%rax,%rcx,8), %rax
movl 0xa2a3(%rip), %ecx      # 0xd8f4
movslq 0x4(%r14), %rdx
cmpl %edx, %ecx
jge 0x369b
cmpl $0x9, %ebx
je 0x367f
cmpl $0x20, %ebx
setge %dl
cmpl $0x7f, %ebx
setne %sil
testb %sil, %dl
jne 0x36ae
movl $0x5e, %edi
callq 0x362c
xorl $0x40, %ebx
jmp 0x3639
movl $0x20, %edi
callq 0x362c
movl 0xa269(%rip), %eax      # 0xd8f8
addl 0xa25f(%rip), %eax      # 0xd8f4
testb $0x7, %al
jne 0x367f
jmp 0x36bc
addl $0x7, %ecx
andl $-0x8, %ecx
movl %ecx, 0xa24d(%rip)      # 0xd8f4
movb $0x24, 0x1(%rdx,%rax)
jmp 0x36bc
testl %ecx, %ecx
js 0x36b6
movb %bl, 0x2(%rax,%rcx)
incl 0xa238(%rip)            # 0xd8f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa22a(%rip), %ecx      # 0xd8f4
leaq 0xa197(%rip), %rax      # 0xd868
cmpl 0x4(%rax), %ecx
jge 0x3704
movq 0xa223(%rip), %rdx      # 0xd900
movslq 0xa20c(%rip), %rsi      # 0xd8f0
movq (%rdx,%rsi,8), %rdx
leal 0x1(%rcx), %esi
movl %esi, 0xa203(%rip)      # 0xd8f4
movslq %ecx, %rcx
movb $0x20, 0x2(%rdx,%rcx)
movl 0xa1f5(%rip), %ecx      # 0xd8f4
cmpl 0x4(%rax), %ecx
jl 0x36e8
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x98b8(%rip), %rax      # 0xdb24
movl (%rax), %ecx
leaq 0x95f3(%rip), %rbx      # 0xd868
movl %ecx, %eax
subl 0x4(%rbx), %eax
cltd
idivl 0xc(%rbx)
addl 0x8(%rbx), %edx
movl %ecx, %eax
subl %edx, %eax
negl %edx
addl %edx, %ecx
incl %ecx
movl %ecx, 0x9667(%rip)      # 0xd8f8
leaq 0x9888(%rip), %r14      # 0xdb20
movl (%r14), %ecx
notl %eax
movl %ecx, 0x964d(%rip)      # 0xd8f0
movl %eax, 0x964b(%rip)      # 0xd8f4
leaq 0x9798(%rip), %rax      # 0xda48
movq (%rax), %rax
movq 0x18(%rax), %r15
cmpl $0x0, 0x14(%r15)
jle 0x42d8
xorl %r12d, %r12d
movzbl 0x18(%r15,%r12), %edi
callq 0x362c
incq %r12
movslq 0x14(%r15), %rax
cmpq %rax, %r12
jl 0x42c1
movl 0x9616(%rip), %eax      # 0xd8f4
cmpl 0x4(%rbx), %eax
jge 0x4310
movq 0x9616(%rip), %rcx      # 0xd900
movslq 0x95ff(%rip), %rdx      # 0xd8f0
movq (%rcx,%rdx,8), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x95f6(%rip)      # 0xd8f4
cltq
movb $0x20, 0x2(%rcx,%rax)
movl 0x95e9(%rip), %eax      # 0xd8f4
cmpl 0x4(%rbx), %eax
jl 0x42f5
movq 0x95e9(%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_O1/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 0x9502(%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 0x43cc
xorl %eax, %eax
callq *0x20(%r12)
cmpb $0x7, %al
je 0x43b4
movl %eax, %ecx
andb $-0x21, %cl
cmpb $0x59, %cl
je 0x43bb
andl $0xdf, %eax
cmpl $0x4e, %eax
jne 0x4366
xorl %eax, %eax
jmp 0x43c0
movl $0x2, %eax
jmp 0x43c0
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x442f
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 0x94ba(%rip), %rdi      # 0xd910
movq %r10, %rsi
callq 0x2200
leaq 0x8f0b(%rip), %rbx      # 0xd370
cmpl $0x0, (%rbx)
jne 0x447b
callq 0x33c8
leaq 0x93f2(%rip), %rcx      # 0xd868
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x93e6(%rip), %r14      # 0xd868
movl (%r14), %edi
cmpl %edi, 0x8cd5(%rip)      # 0xd160
jne 0x4496
cmpl $0x0, 0x8cd0(%rip)      # 0xd164
je 0x44ae
movl %edi, 0x8cc4(%rip)      # 0xd160
movl $0x0, 0x8cbe(%rip)      # 0xd164
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%r14)
movb 0x945c(%rip), %al       # 0xd910
testb %al, %al
je 0x44d8
leaq 0x9452(%rip), %r15      # 0xd911
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r14)
incl 0x8c96(%rip)            # 0xd164
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x44bf
cmpl $0x1, (%rbx)
jne 0x44e3
xorl %eax, %eax
callq *0x40(%r14)
xorl %eax, %eax
callq *0x30(%r14)
leaq 0x9544(%rip), %rax      # 0xda34
movl $0x1, (%rax)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x48c4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq %rbx
leaq 0x8fc3(%rip), %r14      # 0xd868
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r14)
incl 0x88b0(%rip)            # 0xd164
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x48a5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4b04
jmp 0x4b1e
leaq -0x1(%rax), %rcx
cmpb $0x2f, -0x2(%rsi,%rax)
movq %rcx, %rax
je 0x4b26
cmpq $0x1, %rax
jne 0x4b10
jmp 0x4b29
addq %rcx, %rsi
leaq 0xf(%rdi), %rax
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %edx
testl %edx, %edx
je 0x4b4a
cmpl $0x3b, %edx
je 0x4b4a
movb %dl, (%rdi,%rcx)
incq %rcx
cmpq $0xf, %rcx
jne 0x4b2f
jmp 0x4b50
addq %rcx, %rdi
movq %rdi, %rax
movb $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4507(%rip), %rdi      # 0x9229
movq %rsp, %rsi
movl $0x50, %edx
callq 0x4884
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x4d7f
movq %rsp, %rdi
callq 0x4d89
movl %eax, %ebx
testl %eax, %eax
je 0x4d7f
leaq 0x8ced(%rip), %rax      # 0xda38
movq (%rax), %r14
leaq 0x33(%r14), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x2070
andb $-0x3, 0x32(%r14)
leaq 0x8cf5(%rip), %rax      # 0xda60
movq (%rax), %rax
testq %rax, %rax
je 0x4d7f
cmpq %r14, 0x8(%rax)
jne 0x4d6b
orb $0x10, 0x3b(%rax)
jmp 0x4d6b
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4ec4
xorl %ebx, %ebx
testl %eax, %eax
jne 0x4e2b
leaq 0x449d(%rip), %rdi      # 0x9243
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x43cc
leaq 0x8c82(%rip), %r14      # 0xda38
movq (%r14), %rax
movq 0x28(%rax), %rax
movq (%rax), %r15
movl $0x0, %ebp
cmpq %rax, %r15
je 0x4deb
xorl %ebp, %ebp
leaq 0x18(%r15), %rdi
movl 0x14(%r15), %esi
callq 0x4f21
testl %eax, %eax
jne 0x4e0b
incl %ebp
movq (%r15), %r15
movq (%r14), %rax
cmpq 0x28(%rax), %r15
jne 0x4dcc
xorl %eax, %eax
callq 0x4ef7
testl %eax, %eax
jne 0x4e2b
cmpl $0x1, %ebp
jne 0x4e16
leaq 0x444b(%rip), %rdi      # 0x924d
xorl %eax, %eax
callq 0x43cc
jmp 0x4e26
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4ef7
jmp 0x4e2b
leaq 0x443f(%rip), %rdi      # 0x925c
movl %ebp, %esi
xorl %eax, %eax
callq 0x43cc
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8bf5(%rip), %r14      # 0xda38
movq (%r14), %rdi
movl $0x1, %ebx
testb $0x2, 0x32(%rdi)
je 0x4e98
cmpb $0x0, 0x33(%rdi)
je 0x4e88
addq $0x33, %rdi
callq 0x4d89
movl %eax, %ebx
testl %eax, %eax
je 0x4e98
movq (%r14), %rax
andb $-0x3, 0x32(%rax)
leaq 0x8bec(%rip), %rcx      # 0xda60
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x4e98
cmpq %rax, 0x8(%rcx)
jne 0x4e74
orb $0x10, 0x3b(%rcx)
jmp 0x4e74
leaq 0x43a7(%rip), %rdi      # 0x9236
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x43cc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4f4c
movq %rdi, %rbx
movl %esi, %r14d
xorl %r15d, %r15d
movzbl (%rbx,%r15), %edi
movq 0x8ad1(%rip), %rsi      # 0xda10
callq 0x2160
incq %r15
cmpq %r15, %r14
jne 0x4f33
movq 0x8abd(%rip), %rsi      # 0xda10
movl $0xa, %edi
callq 0x2160
movq 0x8aac(%rip), %rdi      # 0xda10
callq 0x2090
testl %eax, %eax
je 0x4f82
leaq 0x4329(%rip), %rdi      # 0x929d
xorl %eax, %eax
callq 0x43cc
movl $0x3, %eax
jmp 0x4f84
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8a5e(%rip), %rdi      # 0xda10
callq 0x2150
cmpl $-0x1, %eax
je 0x4fd8
cmpl $0xa, %eax
je 0x4fcf
cmpq %r15, %r12
je 0x4ff1
movb %al, (%rbx,%r15)
incq %r15
jmp 0x4fab
movb $0x0, (%rbx,%r15)
xorl %eax, %eax
jmp 0x502c
movq 0x8a31(%rip), %rdi      # 0xda10
callq 0x2090
testl %eax, %eax
je 0x5014
leaq 0x42d1(%rip), %rdi      # 0x92c0
jmp 0x5020
movslq %ebp, %rcx
movb %al, (%rbx,%rcx)
movslq %r14d, %rax
movb $0x0, -0x1(%rbx,%rax)
leaq 0x42a7(%rip), %rdi      # 0x92ad
xorl %eax, %eax
callq 0x43cc
movl $0x4, %eax
jmp 0x502c
testq %r15, %r15
je 0x5035
leaq 0x42b0(%rip), %rdi      # 0x92d0
xorl %eax, %eax
callq 0x43cc
movl $0x3, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %eax
jmp 0x502c
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x5070
movq %rax, %r15
movl %ebx, 0x10(%rax)
movl %r14d, 0x14(%rax)
jmp 0x5083
leaq 0x4274(%rip), %rdi      # 0x92eb
xorl %r15d, %r15d
movl %ebx, %esi
xorl %eax, %eax
callq 0x43cc
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8906(%rip), %rax      # 0xda38
movq (%rax), %rax
movb 0x32(%rax), %dl
cmpb $0x1, 0x31(%rax)
movl $0x8, %ecx
cmovel %edi, %ecx
testb $0x2, %dl
jne 0x5152
orl $0x10, %ecx
orb $0x2, %dl
movb %dl, 0x32(%rax)
leaq 0x8907(%rip), %rdx      # 0xda60
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x516c
cmpq %rax, 0x8(%rdx)
jne 0x5159
orb %cl, 0x3b(%rdx)
jmp 0x5159
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x512b
leaq 0x86a3(%rip), %rax      # 0xda48
movq (%rax), %rax
movq 0x18(%rax), %r14
movq 0x20(%rax), %rbx
movl %ebx, %edi
callq 0x503c
testq %rax, %rax
je 0x5483
leaq 0x18(%r14), %rcx
movq %rbx, %rdx
shlq $0x20, %rdx
movslq %ebx, %rdx
movq %rcx, %rsi
je 0x53e9
xorl %esi, %esi
movb (%rcx,%rsi), %dil
movb %dil, 0x18(%rax,%rsi)
incq %rsi
cmpq %rsi, %rdx
jne 0x53d5
addq %rcx, %rsi
movslq 0x14(%r14), %rdi
leaq (%rcx,%rdi), %r8
cmpq %r8, %rsi
je 0x5412
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 0x53f9
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 0x862b(%rip), %rcx      # 0xda60
movq (%rcx), %rsi
movl $0x1, %ecx
testq %rsi, %rsi
je 0x5485
cmpq %r14, 0x10(%rsi)
jne 0x544c
movq %rax, 0x10(%rsi)
cmpq %r14, 0x18(%rsi)
jne 0x5465
movq 0x20(%rsi), %rdi
subq %rdx, %rdi
jge 0x5461
movq %rax, 0x18(%rsi)
jmp 0x5465
movq %rdi, 0x20(%rsi)
cmpq %r14, 0x28(%rsi)
jne 0x547e
movq 0x30(%rsi), %rdi
subq %rdx, %rdi
jge 0x547a
movq %rax, 0x28(%rsi)
jmp 0x547e
movq %rdi, 0x30(%rsi)
movq (%rsi), %rsi
jmp 0x543d
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8417(%rip), %rsi      # 0xda28
cmpq %rsi, 0x8408(%rip)      # 0xda20
jne 0x5655
testq %rsi, %rsi
je 0x5634
movq 0x83f2(%rip), %rdi      # 0xda18
addq $0x400, %rsi            # imm = 0x400
callq 0x21e0
jmp 0x563e
movl $0x400, %edi            # imm = 0x400
callq 0x21a0
testq %rax, %rax
je 0x5678
movq %rax, 0x83ce(%rip)      # 0xda18
addq $0x400, 0x83d3(%rip) # imm = 0x400
movq 0x83bc(%rip), %rax      # 0xda18
movq 0x83bd(%rip), %rcx      # 0xda20
leaq 0x1(%rcx), %rdx
movq %rdx, 0x83b2(%rip)      # 0xda20
movb %bl, (%rax,%rcx)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x5676
// File: /workspace/github_c_makefile_star2_O1/hughbarney[P]pEmacs/line.c
// Function: kdelete
void kdelete ()
{
  if (kbufp != NULL)
    {
      free ((char *) kbufp);
      kbufp = NULL;
      kused = 0;
      ksize = 0;
    }
}

// Assembly:
movq 0x81b2(%rip), %rdi      # 0xda18
testq %rdi, %rdi
je 0x588c
pushq %rax
callq 0x2040
xorl %eax, %eax
movq %rax, 0x819e(%rip)      # 0xda18
movq %rax, 0x819f(%rip)      # 0xda20
movq %rax, 0x81a0(%rip)      # 0xda28
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a56
movq %rax, %rbx
leaq 0x386c(%rip), %rdi      # 0x9387
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x2a56
movq %rax, %r14
movq %rax, 0x7f22(%rip)      # 0xda58
movl $0x40, %edi
callq 0x21a0
testq %rbx, %rbx
je 0x5ba6
testq %rax, %rax
je 0x5ba6
testq %r14, %r14
je 0x5ba6
movq %rbx, 0x7ee2(%rip)      # 0xda38
movq %rax, 0x7f03(%rip)      # 0xda60
movq %rax, 0x7ee4(%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 0x7cd7(%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_O1/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 0x77ce(%rip), %rcx      # 0xd388
testq %rcx, %rcx
je 0x5c28
movswl 0x77ba(%rip), %edi      # 0xd380
cmpl %eax, %edi
jne 0x5bd3
leaq 0x77af(%rip), %rdi      # 0xd380
jmp 0x5bf1
leaq 0x77a6(%rip), %rdi      # 0xd380
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x5c28
movswl 0x18(%rdi), %r8d
addq $0x18, %rdi
cmpl %eax, %r8d
jne 0x5bda
cmpl $0x4, 0x10(%rdi)
jne 0x5c08
movq 0x7e4a(%rip), %rax      # 0xda48
movq 0x8(%rax), %rax
testb $0x4, 0x32(%rax)
jne 0x5c7e
movl $0x0, 0x7e56(%rip)      # 0xda68
movl %esi, %edi
movl %edx, %esi
xorl %eax, %eax
callq *%rcx
movl 0x7e48(%rip), %ecx      # 0xda68
movl %ecx, 0x7e1a(%rip)      # 0xda40
jmp 0x5c9c
movl %eax, %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
addl $-0x20, %ecx
cmpl $0x5e, %ecx
ja 0x5c62
movq 0x7e09(%rip), %rcx      # 0xda48
movq 0x8(%rcx), %rcx
testb $0x4, 0x32(%rcx)
jne 0x5c7e
testl %edx, %edx
jle 0x5c9e
movl $0x0, 0x7e11(%rip)      # 0xda68
movl %edx, %edi
movl %eax, %esi
callq 0x516d
jmp 0x5c1a
leaq 0x3725(%rip), %rdi      # 0x938e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x43cc
movl $0x0, 0x7dc4(%rip)      # 0xda40
jmp 0x5c9a
leaq 0x7be3(%rip), %rcx      # 0xd868
xorl %ebx, %ebx
xorl %eax, %eax
callq *0x50(%rcx)
leaq 0x376e(%rip), %rdi      # 0x9401
xorl %eax, %eax
callq 0x43cc
movl %ebx, %eax
popq %rbx
retq
movl $0x0, 0x7d98(%rip)      # 0xda40
sete %al
movzbl %al, %ebx
jmp 0x5c9a
// File: /workspace/github_c_makefile_star2_O1/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 0x7bb0(%rip), %rbx      # 0xd868
xorl %eax, %eax
callq *0x20(%rbx)
cmpl $0x1b, %eax
jne 0x5ce7
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 0x5cf4
movl %eax, %ecx
orl $0x140, %eax            # imm = 0x140
cmpl $0x20, %ecx
cmovael %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7b6a(%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_O1/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 0x5d54
xorl %eax, %eax
callq 0x2fd0
testl %eax, %eax
je 0x5d54
leaq 0x3669(%rip), %rdi      # 0x939f
callq 0x4344
cmpl $0x1, %eax
je 0x5d54
movl %eax, %ebx
leaq 0x3a79(%rip), %rdi      # 0x97c2
xorl %eax, %eax
callq 0x43cc
movl %ebx, %eax
popq %rbx
retq
xorl %eax, %eax
callq 0x354b
xorl %edi, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O1/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 0x7d06(%rip), %rax      # 0xda70
orq 0x7cdf(%rip), %rax      # 0xda50
je 0x5d85
leaq 0x364a(%rip), %rdi      # 0x93c4
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x43cc
jmp 0x5da6
leaq 0x3640(%rip), %rdi      # 0x93cc
xorl %eax, %eax
callq 0x43cc
leaq 0x73d6(%rip), %rax      # 0xd170
movq %rax, 0x7caf(%rip)      # 0xda50
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq