LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x10, %eax
subl $0x1, %eax
andl $-0x10, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6b27
movl $0x10, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
addq $0x20, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x6b59
movl -0x1c(%rbp), %esi
leaq 0x58f0(%rip), %rdi      # 0xc438
movb $0x0, %al
callq 0x56d0
movq $0x0, -0x8(%rbp)
jmp 0x6b75
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/line.c
// Function: lfree
void lfree (LINE *lp)
{
  BUFFER *bp;
  WINDOW *wp;

  wp = wheadp;
  while (wp != NULL)
    {
      if (wp->w_linep == lp)
	wp->w_linep = lp->l_fp;
      if (wp->w_dotp == lp)
	{
	  wp->w_dotp = lp->l_fp;
	  wp->w_doto = 0;
	}
      if (wp->w_markp == lp)
	{
	  wp->w_markp = lp->l_fp;
	  wp->w_marko = 0;
	}
      wp = wp->w_wndp;
    }
  bp = bheadp;
  while (bp != NULL)
    {
      if (bp->b_nwnd == 0)
	{
	  if (bp->b_dotp == lp)
	    {
	      bp->b_dotp = lp->l_fp;
	      bp->b_doto = 0;
	    }
	  if (bp->b_markp == lp)
	    {
	      bp->b_markp = lp->l_fp;
	      bp->b_marko = 0;
	    }
	}
      bp = bp->b_bufp;
    }
  lp->l_bp->l_fp = lp->l_fp;
  lp->l_fp->l_bp = lp->l_bp;
  free ((char *) lp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9edd(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6bbe
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6be7
movq -0x8(%rbp), %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 0x28(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6c10
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b9a
leaq 0x9f19(%rip), %rax      # 0x10b40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6ca3
movq -0x10(%rbp), %rax
movsbl 0x31(%rax), %eax
cmpl $0x0, %eax
jne 0x6c96
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6c6b
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x6c94
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x6c96
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6c2e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x9d5a(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x31(%rax), %eax
cmpl $0x1, %eax
je 0x6d01
movl $0x8, -0x4(%rbp)
leaq 0x9d40(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x6d34
movl -0x4(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x4(%rbp)
leaq 0x9d21(%rip), %rax      # 0x10a48
movq (%rax), %rax
movsbl 0x32(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x32(%rax)
leaq 0x9d35(%rip), %rax      # 0x10a70
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d7a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x9cf0(%rip), %rcx      # 0x10a48
cmpq (%rcx), %rax
jne 0x6d6d
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x3b(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6d42
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq 0x941e(%rip), %rax      # 0x10a30
cmpq 0x941f(%rip), %rax      # 0x10a38
jne 0x7682
cmpq $0x0, 0x9415(%rip)      # 0x10a38
jne 0x7635
movl $0x400, %edi            # imm = 0x400
callq 0x21c0
movq %rax, -0x10(%rbp)
jmp 0x7653
movq 0x93ec(%rip), %rdi      # 0x10a28
movq 0x93f5(%rip), %rsi      # 0x10a38
addq $0x400, %rsi            # imm = 0x400
callq 0x2200
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7663
movl $0x0, -0x4(%rbp)
jmp 0x76ad
movq -0x10(%rbp), %rax
movq %rax, 0x93ba(%rip)      # 0x10a28
movq 0x93c3(%rip), %rax      # 0x10a38
addq $0x400, %rax            # imm = 0x400
movq %rax, 0x93b6(%rip)      # 0x10a38
movl -0x8(%rbp), %eax
movb %al, %dl
movq 0x939a(%rip), %rax      # 0x10a28
movq 0x939b(%rip), %rcx      # 0x10a30
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x938d(%rip)      # 0x10a30
movb %dl, (%rax,%rcx)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/line.c
// Function: kdelete
void kdelete ()
{
  if (kbufp != NULL)
    {
      free ((char *) kbufp);
      kbufp = NULL;
      kused = 0;
      ksize = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x8f8c(%rip)      # 0x10a28
je 0x7acb
movq 0x8f83(%rip), %rdi      # 0x10a28
callq 0x2040
movq $0x0, 0x8f73(%rip) # 0x10a28
movq $0x0, 0x8f70(%rip) # 0x10a30
movq $0x0, 0x8f6d(%rip) # 0x10a38
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/main.c
// Function: edinit
void edinit (char bname[])
{
  BUFFER *bp;
  WINDOW *wp;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x31c0
movq %rax, -0x10(%rbp)
leaq 0x46e6(%rip), %rdi      # 0xc50f
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x31c0
movq %rax, 0x8c2a(%rip)      # 0x10a68
movl $0x40, %edi
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e64
cmpq $0x0, -0x18(%rbp)
je 0x7e64
cmpq $0x0, 0x8c06(%rip)      # 0x10a68
jne 0x7e6e
movl $0x1, %edi
callq 0x2280
movq -0x10(%rbp), %rax
movq %rax, 0x8bcf(%rip)      # 0x10a48
movq -0x18(%rbp), %rax
movq %rax, 0x8bec(%rip)      # 0x10a70
movq -0x18(%rbp), %rax
movq %rax, 0x8bc9(%rip)      # 0x10a58
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x31(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%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
movb $0x0, 0x38(%rax)
leaq 0x8977(%rip), %rax      # 0x10878
movl (%rax), %eax
subl $0x1, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x39(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x3a(%rax)
movq -0x18(%rbp), %rax
movb $0x18, 0x3b(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x8448(%rip), %rax      # 0x10390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7fdc
movq -0x18(%rbp), %rax
movswl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x7fcb
movq -0x18(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x7f95
movq 0x8ae0(%rip), %rax      # 0x10a58
movq 0x8(%rax), %rax
movsbl 0x32(%rax), %eax
andl $0x4, %eax
cmpl $0x4, %eax
jne 0x7f95
callq 0x8570
movl %eax, -0x4(%rbp)
jmp 0x808f
movl $0x0, 0x8ad9(%rip)      # 0x10a78
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movb $0x0, %al
callq *%rcx
movl %eax, -0x1c(%rbp)
movl 0x8abe(%rip), %eax      # 0x10a78
movl %eax, 0x8a90(%rip)      # 0x10a50
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x808f
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x7f4c
cmpl $0x20, -0x8(%rbp)
jl 0x7fe8
cmpl $0x7e, -0x8(%rbp)
jle 0x7ffa
cmpl $0xa0, -0x8(%rbp)
jl 0x8070
cmpl $0xfe, -0x8(%rbp)
jg 0x8070
movq 0x8a57(%rip), %rax      # 0x10a58
movq 0x8(%rax), %rax
movsbl 0x32(%rax), %ecx
andl $0x4, %ecx
movl $0x4, %eax
cmpl %ecx, %eax
jne 0x801f
callq 0x8570
movl %eax, -0x4(%rbp)
jmp 0x808f
cmpl $0x0, -0x10(%rbp)
jg 0x8044
movl $0x0, 0x8a21(%rip)      # 0x10a50
movl -0x10(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x808f
movl $0x0, 0x8a2a(%rip)      # 0x10a78
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x6d80
movl %eax, -0x1c(%rbp)
movl 0x8a16(%rip), %eax      # 0x10a78
movl %eax, 0x89e8(%rip)      # 0x10a50
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x808f
leaq 0x449f(%rip), %rdi      # 0xc516
movb $0x0, %al
callq 0x56d0
movl $0x0, 0x89c8(%rip)      # 0x10a50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x87c9(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x20(%rcx)
movl %eax, -0x8(%rbp)
cmpl $0x1b, -0x8(%rbp)
jne 0x80d2
callq 0x8100
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x4(%rbp)
jmp 0x80f2
cmpl $0x0, -0x8(%rbp)
jl 0x80ec
cmpl $0x1f, -0x8(%rbp)
jg 0x80ec
movl -0x8(%rbp), %eax
addl $0x40, %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8769(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x20(%rcx)
movl %eax, -0x4(%rbp)
cmpl $0x61, -0x4(%rbp)
jl 0x812c
cmpl $0x7a, -0x4(%rbp)
jg 0x812c
movl -0x4(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x8146
cmpl $0x1f, -0x4(%rbp)
jg 0x8146
movl -0x4(%rbp), %eax
addl $0x40, %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x8184
movb $0x0, %al
callq 0x3cd0
cmpl $0x0, %eax
je 0x8184
leaq 0x43b0(%rip), %rdi      # 0xc527
callq 0x5620
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jne 0x8192
movb $0x0, %al
callq 0x4450
xorl %edi, %edi
callq 0x2280
leaq 0x4740(%rip), %rdi      # 0xc8d9
movb $0x0, %al
callq 0x56d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x889a(%rip)      # 0x10a60
jne 0x81d2
cmpq $0x0, 0x88b0(%rip)      # 0x10a80
je 0x81e9
leaq 0x4373(%rip), %rdi      # 0xc54c
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x820c
leaq 0x4364(%rip), %rdi      # 0xc554
movb $0x0, %al
callq 0x56d0
leaq 0x7f82(%rip), %rax      # 0x10180
movq %rax, 0x885b(%rip)      # 0x10a60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/main.c
// Function: ctlxrp
int ctlxrp (int f, int n)
{
  if (kbdmip == NULL)
    {
      mlwrite ("Not now");
      return (FALSE);
    }
  mlwrite ("[End macro]");
  kbdmip = NULL;
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x882a(%rip)      # 0x10a60
jne 0x824f
leaq 0x430d(%rip), %rdi      # 0xc54c
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x826f
leaq 0x430c(%rip), %rdi      # 0xc562
movb $0x0, %al
callq 0x56d0
movq $0x0, 0x87f8(%rip) # 0x10a60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/main.c
// Function: ctlxe
int ctlxe (int f, int n)
{
  int c, af, an, s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x87ca(%rip)      # 0x10a60
jne 0x82a2
cmpq $0x0, 0x87e0(%rip)      # 0x10a80
je 0x82bc
leaq 0x42c5(%rip), %rdi      # 0xc56e
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x83be
cmpl $0x0, -0xc(%rbp)
jg 0x82ce
movl $0x1, -0x4(%rbp)
jmp 0x83be
jmp 0x82d0
leaq 0x7ea9(%rip), %rax      # 0x10180
movq %rax, 0x87a2(%rip)      # 0x10a80
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq 0x878d(%rip), %rax      # 0x10a80
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, 0x877f(%rip)      # 0x10a80
movswl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x155, %eax            # imm = 0x155
jne 0x834b
movl $0x1, -0x14(%rbp)
movq 0x8764(%rip), %rax      # 0x10a80
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, 0x8756(%rip)      # 0x10a80
movswl (%rax), %eax
movl %eax, -0x18(%rbp)
movq 0x8749(%rip), %rax      # 0x10a80
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, 0x873b(%rip)      # 0x10a80
movswl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x429, -0x10(%rbp)     # imm = 0x429
movb %al, -0x1d(%rbp)
je 0x837a
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x7f30
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x82de
movq $0x0, 0x86f0(%rip) # 0x10a80
xorl %eax, %eax
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x1e(%rbp)
jne 0x83ad
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x82d0
movl -0x1c(%rbp), %eax
movl %eax, -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/main.c
// Function: ctrlg
int ctrlg (int f, int n)
{
  (*term.t_beep) ();
  if (kbdmip != NULL)
    {
      kbdm[0] = (CTLX | ')');
      kbdmip = NULL;
    }
  mlwrite ("[Aborted]");
  return (ABORT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x8493(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x50(%rcx)
cmpq $0x0, 0x866e(%rip)      # 0x10a60
je 0x8408
movw $0x429, 0x7d83(%rip)    # imm = 0x429
movq $0x0, 0x8658(%rip) # 0x10a60
leaq 0x4170(%rip), %rdi      # 0xc57f
movb $0x0, %al
callq 0x56d0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/main.c
// Function: extendedcmd
int extendedcmd (int f, int n)
{
  int (*cmd)();
  int c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x8100
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x33, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x24, %eax
ja 0x8533
movq -0x28(%rbp), %rax
leaq 0x3ffa(%rip), %rcx      # 0xc460
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x5b16(%rip), %rax     # 0x2960
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x5cf6(%rip), %rax     # 0x2790
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x5ee6(%rip), %rax     # 0x25b0
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x5fe6(%rip), %rax     # 0x24c0
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x6066(%rip), %rax     # 0x2450
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x6046(%rip), %rax     # 0x2480
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq -0x6053(%rip), %rax     # 0x2480
movq %rax, -0x18(%rbp)
jmp 0x854a
leaq 0x590(%rip), %rax       # 0x8a70
movq %rax, -0x18(%rbp)
callq 0x8100
jmp 0x854a
leaq -0x5962(%rip), %rax     # 0x2b90
movq %rax, -0x18(%rbp)
callq 0x8100
jmp 0x854a
leaq -0x5a94(%rip), %rax     # 0x2a70
movq %rax, -0x18(%rbp)
callq 0x8100
jmp 0x854a
leaq -0x5c76(%rip), %rax     # 0x28a0
movq %rax, -0x18(%rbp)
callq 0x8100
jmp 0x854a
leaq -0x5c28(%rip), %rax     # 0x2900
movq %rax, -0x18(%rbp)
callq 0x8100
jmp 0x854a
leaq 0x3fdc(%rip), %rdi      # 0xc516
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x855b
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movb $0x0, %al
callq *%rcx
movl %eax, -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/main.c
// Function: debug
void debug(char *format, ...)
{
    char buffer[256];
    va_list args;
    va_start (args, format);

    static FILE *debug_fp = NULL;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
testb %al, %al
je 0x85e7
movaps %xmm0, -0x1b0(%rbp)
movaps %xmm1, -0x1a0(%rbp)
movaps %xmm2, -0x190(%rbp)
movaps %xmm3, -0x180(%rbp)
movaps %xmm4, -0x170(%rbp)
movaps %xmm5, -0x160(%rbp)
movaps %xmm6, -0x150(%rbp)
movaps %xmm7, -0x140(%rbp)
movq %r9, -0x1b8(%rbp)
movq %r8, -0x1c0(%rbp)
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1d0(%rbp)
movq %rsi, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x130(%rbp), %rax
leaq -0x1e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x844b(%rip)      # 0x10a88
jne 0x8659
leaq 0x3f5e(%rip), %rdi      # 0xc5a4
leaq 0x4263(%rip), %rsi      # 0xc8b0
callq 0x2250
movq %rax, 0x842f(%rip)      # 0x10a88
movq -0x8(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
leaq -0x130(%rbp), %rdx
callq 0x2220
movq -0x1e8(%rbp), %rdx
movq 0x8403(%rip), %rdi      # 0x10a88
leaq 0x408b(%rip), %rsi      # 0xc717
xorl %eax, %eax
callq 0x21b0
movq 0x83ee(%rip), %rdi      # 0x10a88
callq 0x21d0
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: getccol
int getccol (int bflg)
{
  int c, i, col;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
leaq 0x8198(%rip), %rcx      # 0x10a58
movq (%rcx), %rcx
cmpq 0x20(%rcx), %rax
jge 0x893b
leaq 0x8188(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
je 0x88fc
cmpl $0x9, -0x8(%rbp)
je 0x88fc
cmpl $0x0, -0x4(%rbp)
je 0x88fc
jmp 0x893b
cmpl $0x9, -0x8(%rbp)
jne 0x890d
movl -0x10(%rbp), %eax
orl $0x7, %eax
movl %eax, -0x10(%rbp)
jmp 0x8924
cmpl $0x20, -0x8(%rbp)
jl 0x8919
cmpl $0x7f, -0x8(%rbp)
jne 0x8922
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8924
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x88b5
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: quote
int quote (int f, int n)
{
  int s, c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x7f23(%rip), %rcx      # 0x10878
movb $0x0, %al
callq *0x20(%rcx)
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x896c
movl $0x0, -0x4(%rbp)
jmp 0x89c7
cmpl $0x0, -0xc(%rbp)
jne 0x897b
movl $0x1, -0x4(%rbp)
jmp 0x89c7
cmpl $0xa, -0x14(%rbp)
jne 0x89b9
jmp 0x8983
movb $0x0, %al
callq 0x7170
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x15(%rbp)
jne 0x89aa
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x8983
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x89c7
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x6d80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: newline
int newline (int f, int n)
{
  int s;

  if (n < 0)
    return (FALSE);

  /* insert some lines */
  while (n--)
    {
      if ((s = lnewline ()) != TRUE)
	return (s);
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8a2d
movl $0x0, -0x4(%rbp)
jmp 0x8a5f
jmp 0x8a2f
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x8a58
movb $0x0, %al
callq 0x7170
movl %eax, -0x10(%rbp)
cmpl $0x1, %eax
je 0x8a56
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8a5f
jmp 0x8a2f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: forwdel
int forwdel (int f, int n)
{
  if (n < 0)
    return (backdel (f, -n));
  if (f != FALSE)
    {			       /* Really a kill */
      if ((lastflag & CFKILL) == 0)
	kdelete ();
      thisflag |= CFKILL;
    }
  return (ldelete (n, f));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8a96
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x8ae0
movl %eax, -0x4(%rbp)
jmp 0x8ad7
cmpl $0x0, -0x8(%rbp)
je 0x8ac9
leaq 0x7fad(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x8ab4
movb $0x0, %al
callq 0x7a90
leaq 0x7fbd(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x7fb1(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x7380
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: backdel
int backdel (int f, int n)
{
  int s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8b06
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x8a70
movl %eax, -0x4(%rbp)
jmp 0x8b60
cmpl $0x0, -0x8(%rbp)
je 0x8b39
leaq 0x7f3d(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x8b24
movb $0x0, %al
callq 0x7a90
leaq 0x7f4d(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x7f41(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x24c0
movl %eax, -0x10(%rbp)
cmpl $0x1, %eax
jne 0x8b5a
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x7380
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: killtext
int killtext (int f, int n)
{
  LINE *nextp;
  int chunk;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x7ecb(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x8b96
movb $0x0, %al
callq 0x7a90
leaq 0x7edb(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x7ecf(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
jne 0x8be6
leaq 0x7ea0(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rax), %rax
leaq 0x7e8e(%rip), %rcx      # 0x10a58
movq (%rcx), %rcx
subq 0x20(%rcx), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x8be1
movl $0x1, -0x1c(%rbp)
jmp 0x8cbf
cmpl $0x0, -0xc(%rbp)
jne 0x8c14
leaq 0x7e65(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rax
movl %eax, -0x1c(%rbp)
leaq 0x7e54(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq $0x0, 0x20(%rax)
jmp 0x8cbd
cmpl $0x0, -0xc(%rbp)
jle 0x8ca4
leaq 0x7e33(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rax), %rax
leaq 0x7e21(%rip), %rcx      # 0x10a58
movq (%rcx), %rcx
subq 0x20(%rcx), %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
leaq 0x7e0c(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x8ca2
movq -0x18(%rbp), %rax
leaq 0x7dd5(%rip), %rcx      # 0x10a48
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x8c85
movl $0x0, -0x4(%rbp)
jmp 0x8ccf
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x1, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8c5a
jmp 0x8cbb
leaq 0x3936(%rip), %rdi      # 0xc5e1
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0x8ccf
jmp 0x8cbd
jmp 0x8cbf
movl -0x1c(%rbp), %edi
movl $0x1, %esi
callq 0x7380
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/random.c
// Function: yank
int yank (int f, int n)
{
  int c, i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8cfd
movl $0x0, -0x4(%rbp)
jmp 0x8d7b
jmp 0x8cff
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x8d74
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x7ad0
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jl 0x8d72
cmpl $0xa, -0x10(%rbp)
jne 0x8d4a
xorl %edi, %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x7170
cmpl $0x0, %eax
jne 0x8d48
movl $0x0, -0x4(%rbp)
jmp 0x8d7b
jmp 0x8d67
movl -0x10(%rbp), %esi
movl $0x1, %edi
callq 0x6d80
cmpl $0x0, %eax
jne 0x8d65
movl $0x0, -0x4(%rbp)
jmp 0x8d7b
jmp 0x8d67
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8d16
jmp 0x8cff
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/region.c
// Function: killregion
int killregion (int f, int n)
{
  REGION region;
  int s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8e30
movl %eax, -0x2c(%rbp)
cmpl $0x1, %eax
je 0x8db7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e1b
leaq 0x7c92(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x8dcf
movb $0x0, %al
callq 0x7a90
leaq 0x7ca2(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x7c96(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
leaq 0x7c69(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
leaq 0x7c57(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl %eax, %edi
movl $0x1, %esi
callq 0x7380
movl %eax, -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/region.c
// Function: copyregion
int copyregion (int f, int n)
{
  LINE *linep;
  REGION region;
  int loffs, s;

  if ((s = getregion (&region)) != TRUE)
    return (s);
  if ((lastflag & CFKILL) == 0) /* Kill type command */
    kdelete ();
  thisflag |= CFKILL;
  linep = region.r_linep;	/* Current line */
  loffs = region.r_offset;	/* Current offset */
  while (region.r_size--)
    {
      if (loffs == llength (linep))
	{			/* End of line */
	  if ((s = kinsert ('\n')) != TRUE)
	    return (s);
	  linep = lforw (linep);
	  loffs = 0;
	}
      else
	{			/* Middle of line */
	  if ((s = kinsert (lgetc (linep, loffs))) != TRUE)
	    return (s);
	  ++loffs;
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8e30
movl %eax, -0x38(%rbp)
cmpl $0x1, %eax
je 0x914a
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9212
leaq 0x78ff(%rip), %rax      # 0x10a50
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x9162
movb $0x0, %al
callq 0x7a90
leaq 0x790f(%rip), %rax      # 0x10a78
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x7903(%rip), %rax      # 0x10a78
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x920b
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x91d5
movl $0xa, %edi
callq 0x7600
movl %eax, -0x38(%rbp)
cmpl $0x1, %eax
je 0x91c1
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9212
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
jmp 0x9206
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %edi
andl $0xff, %edi
callq 0x7600
movl %eax, -0x38(%rbp)
cmpl $0x1, %eax
je 0x91fd
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9212
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9186
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/strlcpy.c
// Function: strlcpy
size_t
strlcpy(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;

	/* Copy as many bytes as will fit */
	if (n != 0) {
		while (--n != 0) {
			if ((*d++ = *s++) == '\0')
				break;
		}
	}

	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0';		/* NUL-terminate dst */
		while (*s++)
			;
	}

	return(s - src - 1);	/* count does not include NUL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x9293
jmp 0x9251
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9291
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %al
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x928f
jmp 0x9291
jmp 0x9251
jmp 0x9293
cmpq $0x0, -0x30(%rbp)
jne 0x92c2
cmpq $0x0, -0x18(%rbp)
je 0x92a8
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x92aa
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpb $0x0, (%rax)
je 0x92c0
jmp 0x92aa
jmp 0x92c2
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: readpattern
int
readpattern(char *prompt)
{
	char	tpat[NPAT];
	char 	nprompt[NPAT + 20]; // XXX
	int	retval;
	int r;

	if (pat[0] == '\0')
	  r = mlreplyt(prompt, tpat, NPAT, '\n'); /* Read pattern */
	else {
	  sprintf(nprompt, "%s: (default %s) ", prompt, pat);
	  r = mlreplyt(nprompt, tpat, NPAT, '\n'); /* Read pattern */
	}

	if (r == ABORT) {
		retval = ABORT;
		/* specified */
	} else if (r == TRUE) {
		(void)strlcpy(pat, tpat, NPAT);
		retval = TRUE;
		/*  cr but old one */
	} else if (r == FALSE && pat[0] != '\0') {
		retval = TRUE;
	} else
		retval = FALSE;
	return (retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6cea(%rip), %rax      # 0x10a90
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9dcd
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x50, %edx
movl $0xa, %ecx
callq 0x57e0
movl %eax, -0xd8(%rbp)
jmp 0x9e0d
leaq -0xd0(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x28fc(%rip), %rsi      # 0xc6db
leaq 0x6caa(%rip), %rcx      # 0x10a90
movb $0x0, %al
callq 0x2270
leaq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x50, %edx
movl $0xa, %ecx
callq 0x57e0
movl %eax, -0xd8(%rbp)
cmpl $0x2, -0xd8(%rbp)
jne 0x9e22
movl $0x2, -0xd4(%rbp)
jmp 0x9e7e
cmpl $0x1, -0xd8(%rbp)
jne 0x9e4c
leaq -0x60(%rbp), %rsi
leaq 0x6c5a(%rip), %rdi      # 0x10a90
movl $0x50, %edx
callq 0x9220
movl $0x1, -0xd4(%rbp)
jmp 0x9e7c
cmpl $0x0, -0xd8(%rbp)
jne 0x9e70
leaq 0x6c34(%rip), %rax      # 0x10a90
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9e70
movl $0x1, -0xd4(%rbp)
jmp 0x9e7a
movl $0x0, -0xd4(%rbp)
jmp 0x9e7c
jmp 0x9e7e
movl -0xd4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: eq
static int
eq(int bc, int pc, int xcase)
{
	bc = CHARMASK(bc);
	pc = CHARMASK(pc);
	if (bc == pc)
		return (TRUE);
	if (xcase)
		return (FALSE);
	if (ISUPPER(bc))
		return (TOLOWER(bc) == pc);
	if (ISUPPER(pc))
		return (bc == TOLOWER(pc));
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0xa2f0
movl $0x1, -0x4(%rbp)
jmp 0xa35c
cmpl $0x0, -0x10(%rbp)
je 0xa2ff
movl $0x0, -0x4(%rbp)
jmp 0xa35c
movl $0x41, %eax
cmpl -0x8(%rbp), %eax
jg 0xa329
movl $0x5a, %eax
cmpl -0x8(%rbp), %eax
jl 0xa329
movl -0x8(%rbp), %eax
addl $0x20, %eax
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xa35c
movl $0x41, %eax
cmpl -0xc(%rbp), %eax
jg 0xa355
movl $0x5a, %eax
cmpl -0xc(%rbp), %eax
jl 0xa355
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x20, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xa35c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_lpush
static void
is_lpush(void)
{
	int	ctp;

	ctp = cip + 1;
	if (ctp >= NSRCH)
		ctp = 0;
	cmds[ctp].s_code = SRCH_NOPR;
	cmds[ctp].s_doto = curwp->w_doto;
	cmds[ctp].s_dotp = curwp->w_dotp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x6576(%rip), %eax      # 0x10b50
addl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jl 0xa5f0
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x6565(%rip), %rax      # 0x10b60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
leaq 0x6449(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rax
movl %eax, %ecx
movslq -0x4(%rbp), %rdx
leaq 0x653d(%rip), %rax      # 0x10b60
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
leaq 0x6424(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rcx
movslq -0x4(%rbp), %rdx
leaq 0x651a(%rip), %rax      # 0x10b60
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_prompt
static void
is_prompt(int dir, int flag, int success)
{
	if (dir == SRCH_FORW) {
		if (success != FALSE)
			is_dspl("I-search", flag);
		else
			is_dspl("Failing I-search", flag);
	} else if (dir == SRCH_BACK) {
		if (success != FALSE)
			is_dspl("I-search backward", flag);
		else
			is_dspl("Failing I-search backward", flag);
	} else
		mlwrite("Broken call to is_prompt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0xa6ef
cmpl $0x0, -0xc(%rbp)
je 0xa6de
movl -0x8(%rbp), %esi
leaq 0x204b(%rip), %rdi      # 0xc722
callq 0xa960
jmp 0xa6ed
movl -0x8(%rbp), %esi
leaq 0x2032(%rip), %rdi      # 0xc71a
callq 0xa960
jmp 0xa72d
cmpl $-0x2, -0x4(%rbp)
jne 0xa71d
cmpl $0x0, -0xc(%rbp)
je 0xa70c
movl -0x8(%rbp), %esi
leaq 0x202e(%rip), %rdi      # 0xc733
callq 0xa960
jmp 0xa71b
movl -0x8(%rbp), %esi
leaq 0x2015(%rip), %rdi      # 0xc72b
callq 0xa960
jmp 0xa72b
leaq 0x2021(%rip), %rdi      # 0xc745
movb $0x0, %al
callq 0x56d0
jmp 0xa72d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_undo
static void
is_undo(int *pptr, int *dir)
{
	int	redo = FALSE;

	switch (cmds[cip].s_code) {
	case SRCH_BEGIN:
	case SRCH_NOPR:
		*pptr = -1;
		break;
	case SRCH_MARK:
		break;
	case SRCH_FORW:
		*dir = SRCH_BACK;
		redo = TRUE;
		break;
	case SRCH_BACK:
		*dir = SRCH_FORW;
		redo = TRUE;
		break;
	case SRCH_ACCM:
	default:
		*pptr -= 1;
		if (*pptr < 0)
			*pptr = 0;
		pat[*pptr] = '\0';
		break;
	}
	is_pop();
	if (redo)
		is_undo(pptr, dir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq 0x63d2(%rip), %rax      # 0x10b50
leaq (%rax,%rax,2), %rcx
leaq 0x63d7(%rip), %rax      # 0x10b60
movl (%rax,%rcx,8), %eax
addl $0x5, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0xa7e4
movq -0x20(%rbp), %rax
leaq 0x1e6f(%rip), %rcx      # 0xc614
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xa814
jmp 0xa814
movq -0x10(%rbp), %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movl $0x1, -0x14(%rbp)
jmp 0xa814
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, -0x14(%rbp)
jmp 0xa814
jmp 0xa7e4
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jge 0xa802
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x6280(%rip), %rax      # 0x10a90
movb $0x0, (%rax,%rcx)
callq 0xa9b0
cmpl $0x0, -0x14(%rbp)
je 0xa82c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa760
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_find
static int
is_find(int dir)
{
  int	 plen, odoto;
	LINE	*odotp;

	odoto = curwp->w_doto;
	odotp = curwp->w_dotp;
	plen = strlen(pat);
	if (plen != 0) {
		if (dir == SRCH_FORW) {
			(void)backchar(FFARG | FFRAND, plen);
			if (forwsrch() == FALSE) {
				curwp->w_doto = odoto;
				curwp->w_dotp = odotp;
				return (FALSE);
			}
			return (TRUE);
		}
		if (dir == SRCH_BACK) {
			(void)forwchar(FFARG | FFRAND, plen);
			if (backsrch() == FALSE) {
				curwp->w_doto = odoto;
				curwp->w_dotp = odotp;
				return (FALSE);
			}
			return (TRUE);
		}
		mlwrite("bad call to is_find");
		return (FALSE);
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0x6206(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x20(%rax), %rax
movl %eax, -0x10(%rbp)
leaq 0x61f5(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x621b(%rip), %rdi      # 0x10a90
callq 0x20e0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa944
cmpl $-0x1, -0x8(%rbp)
jne 0xa8da
movl -0xc(%rbp), %esi
movl $0xf, %edi
callq 0x24c0
callq 0xa060
cmpl $0x0, %eax
jne 0xa8d1
movslq -0x10(%rbp), %rcx
leaq 0x61a9(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
leaq 0x6197(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa94b
movl $0x1, -0x4(%rbp)
jmp 0xa94b
cmpl $-0x2, -0x8(%rbp)
jne 0xa92d
movl -0xc(%rbp), %esi
movl $0xf, %edi
callq 0x25b0
callq 0xa370
cmpl $0x0, %eax
jne 0xa924
movslq -0x10(%rbp), %rcx
leaq 0x6156(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
leaq 0x6144(%rip), %rax      # 0x10a58
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa94b
movl $0x1, -0x4(%rbp)
jmp 0xa94b
leaq 0x1e36(%rip), %rdi      # 0xc76a
movb $0x0, %al
callq 0x56d0
movl $0x0, -0x4(%rbp)
jmp 0xa94b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hughbarney[P]pEmacs/search.c
// Function: is_dspl
static void
is_dspl(char *prompt, int flag)
{
  if (flag != FALSE) {
	mlwrite("%s: ", prompt);
  } else {
	mlwrite("%s: %s", prompt, pat);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa989
movq -0x8(%rbp), %rsi
leaq 0x1dde(%rip), %rdi      # 0xc75e
movb $0x0, %al
callq 0x56d0
jmp 0xa9a2
movq -0x8(%rbp), %rsi
leaq 0x1dcf(%rip), %rdi      # 0xc763
leaq 0x60f5(%rip), %rdx      # 0x10a90
movb $0x0, %al
callq 0x56d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)