LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotoeop
int gotoeop (int f, int n)
{
  int suc;			/* success of last backchar */

  if (n < 0)			/* the other way.. */
    return (gotobop (f, -n));

  while (n-- > 0)
    {				/* for each one asked for */
      /* first scan forward until we are in a word */
      suc = forwchar (FALSE, 1);
      while (!inword () && suc)
	suc = forwchar (FALSE, 1);
      curwp->w_doto = 0;	/* and go to the B-O-Line */
      if (suc)			/* of next line if not at EOF */
	curwp->w_dotp = lforw (curwp->w_dotp);

      /* and scan forword until hit a <NL><NL> or <NL><TAB> or a <NL><SPACE> */
      while (curwp->w_dotp != curbp->b_linep)
	{
	  if (llength (curwp->w_dotp) != 0 &&
	      lgetc (curwp->w_dotp, curwp->w_doto) != TAB &&
	      lgetc (curwp->w_dotp, curwp->w_doto) != ' ')
	    curwp->w_dotp = lforw (curwp->w_dotp);
	  else
	    break;
	}

      /* and then backward until we are in a word */
      suc = backchar (FALSE, 1);
      while (suc && !inword ())
	{
	  suc = backchar (FALSE, 1);
	}
      curwp->w_doto = llength (curwp->w_dotp); /* and to the EOL */
    }
  curwp->w_flag |= WFMOVE;	/* force screen update */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
js 0x2718
pushq $0x1
popq %rbp
leaq 0xa1d4(%rip), %r15      # 0xc848
leaq 0xa1bd(%rip), %r12      # 0xc838
testl %ebx, %ebx
jle 0x270f
decl %ebx
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
movl %eax, %r14d
xorl %eax, %eax
callq 0x74a9
testl %eax, %eax
jne 0x26a1
testl %r14d, %r14d
jne 0x2685
movq (%r15), %rax
andq $0x0, 0x20(%rax)
movq 0x18(%rax), %rcx
testl %r14d, %r14d
je 0x26b9
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%r12), %rdx
movq 0x28(%rdx), %rdx
cmpq %rdx, %rcx
je 0x26e3
cmpl $0x0, 0x14(%rcx)
je 0x26e3
movzbl 0x18(%rcx), %esi
cmpl $0x9, %esi
je 0x26e3
cmpl $0x20, %esi
je 0x26e3
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x26c1
xorl %edi, %edi
movl %ebp, %esi
callq 0x2357
testl %eax, %eax
je 0x26fb
xorl %eax, %eax
callq 0x74a9
testl %eax, %eax
je 0x26e3
movq (%r15), %rax
movq 0x18(%rax), %rcx
movslq 0x14(%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x267b
movq (%r15), %rax
orb $0x2, 0x3b(%rax)
jmp 0x2721
negl %ebx
movl %ebx, %esi
callq 0x25a1
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: usebuffer
int usebuffer (int f, int n)
{
  BUFFER *bp;
  char bufn[NBUFN];
  int s;

  if ((s = mlreply ("Use buffer: ", bufn, NBUFN)) != TRUE)
    return (s);
  if ((bp = bfind (bufn, TRUE, 0)) == NULL)
    return (FALSE);
  return (swbuffer (bp));
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x56c5(%rip), %rdi      # 0x800f
movq %rsp, %rsi
pushq $0x10
popq %rdx
callq 0x3e7b
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x297c
movq %rsp, %rdi
pushq $0x1
popq %rbp
xorl %ebx, %ebx
movl %ebp, %esi
xorl %edx, %edx
callq 0x2985
testq %rax, %rax
je 0x297c
movq %rax, %rdi
callq 0x2844
movl %ebp, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: killbuffer
int killbuffer (int f, int n)
{
  BUFFER *bp;
  char bufn[NBUFN];
  int s;

  if ((s = mlreply ("Kill buffer: ", bufn, NBUFN)) != TRUE)
    return (s);
  if ((bp = bfind (bufn, FALSE, 0)) == NULL) /* Easy if unknown */
    return (TRUE);
  return (zotbuf (bp));
}

// Assembly:
subq $0x18, %rsp
leaq 0x5548(%rip), %rdi      # 0x801c
movq %rsp, %rsi
pushq $0x10
popq %rdx
callq 0x3e7b
cmpl $0x1, %eax
jne 0x2b02
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2985
testq %rax, %rax
je 0x2aff
movq %rax, %rdi
callq 0x2b07
jmp 0x2b02
pushq $0x1
popq %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: zotbuf
int zotbuf (BUFFER *bp)
{
  BUFFER *bp1, *bp2;
  int s;

  if (bp->b_nwnd != 0)
    {				/* Error if on screen */
      mlwrite ("Buffer is being displayed");
      return (FALSE);
    }
  if ((s = bclear (bp)) != TRUE) /* Blow text away */
    return (s);
  free (bp->b_linep);		/* Release header line */
  bp1 = 0;			/* Find the header */
  bp2 = bheadp;
  while (bp2 != bp)
    {
      bp1 = bp2;
      bp2 = bp2->b_bufp;
    }
  bp2 = bp2->b_bufp;		/* Next one in chain */
  if (bp1 == NULL)		/* Unlink it */
    bheadp = bp2;
  else
    bp1->b_bufp = bp2;
  free (bp);			/* Release buffer block */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x31(%rdi)
je 0x2b22
leaq 0x5513(%rip), %rdi      # 0x802a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3e83
jmp 0x2b6e
movq %rdi, %rbx
callq 0x2b77
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2b6e
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0x9d2f(%rip), %rdx      # 0xc870
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2b43
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2b60
leaq 0x9d10(%rip), %rax      # 0xc870
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2040
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: namebuffer
int namebuffer (int f, int n)
{
  BUFFER *bp;			/* pointer to scan through all buffers */
  char bufn[NBUFN];		/* buffer to hold buffer name */

  /* prompt for and get the new buffer name */
 ask:
  if (mlreply ("Change buffer name to: ", bufn, NBUFN) != TRUE)
    return (FALSE);

  /* and check for duplicates */
  bp = bheadp;
  while (bp != 0)
    {
      if (bp != curbp)
	{
	  /* if the names the same */
	  if (strcmp (bufn, bp->b_bname) == 0)
	    goto ask;		/* try again */
	}
      bp = bp->b_bufp;		/* onward */
    }

  strncpy (curbp->b_bname, bufn, NBUFN); /* copy buffer name to structure */
  curwp->w_flag |= WFMODE;		 /* make mode line replot */
  mlerase ();
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsp, %r14
pushq $0x10
popq %rbp
leaq 0x9c54(%rip), %r12      # 0xc838
leaq 0x9c85(%rip), %rbx      # 0xc870
leaq 0x5452(%rip), %rdi      # 0x8044
movq %r14, %rsi
movl %ebp, %edx
callq 0x3e7b
cmpl $0x1, %eax
jne 0x2c67
movq (%r12), %r15
movq %rbx, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x2c2b
cmpq %r15, %r13
je 0x2c08
leaq 0x83(%r13), %rsi
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
jne 0x2c08
jmp 0x2beb
addq $0x83, %r15
movq %rsp, %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2060
leaq 0x9c01(%rip), %rax      # 0xc848
movq (%rax), %rax
orb $0x10, 0x3b(%rax)
xorl %eax, %eax
callq 0x2fc0
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x2c58
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlwrite
void mlwrite (char *fmt, int arg)
{
  int c;
  char *ap;

  if (eolexist == FALSE)
    {
      mlerase ();
      (*term.t_flush) ();
    }
  movecursor (term.t_nrow, 0);
  ap = (char *) &arg;
  while ((c = *fmt++) != 0)
    {
      if (c != '%')
	{
	  (*term.t_putchar) (c);
	  ++ttcol;
	}
      else
	{
	  c = *fmt++;
	  switch (c)
	    {
	    case 'd':
	      mlputi (*(int *) ap, 10);
	      ap += sizeof (int);
	      break;

	    case 'o':
	      mlputi (*(int *) ap, 8);
	      ap += sizeof (int);
	      break;

	    case 'x':
	      mlputi (*(int *) ap, 16);
	      ap += sizeof (int);
	      break;

	    case 'D':
	      mlputli (*(long *) ap, 10);
	      ap += sizeof (long);
	      break;

	    case 's':
	      mlputs (*(char **) &ap);
	      ap += sizeof (char *);
	      break;

	    case 'c':
	      (*term.t_putchar) (*ap);
	      ++ttcol;
	      ap += sizeof (char *);
	      break;

	    default:
	      (*term.t_putchar) (c);
	      ++ttcol;
	    }
	}
    }
  if (eolexist == TRUE)
    (*term.t_eeol) ();
  (*term.t_flush) ();
  mpresf = TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
leaq 0x8478(%rip), %rax      # 0xc314
cmpl $0x0, (%rax)
jne 0x3eb2
callq 0x2fc0
leaq 0x88d3(%rip), %rcx      # 0xc780
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x88c7(%rip), %r13      # 0xc780
movl (%r13), %edi
xorl %esi, %esi
callq 0x2f94
leaq 0x4(%rsp), %r14
pushq $0xa
popq %rbp
pushq $0x10
popq %r15
pushq $0x8
popq %r12
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x3ef8
testl %eax, %eax
je 0x3f78
incq %rbx
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r13)
incl 0x820e(%rip)            # 0xc104
jmp 0x3ed4
movzbl 0x1(%rbx), %eax
addq $0x2, %rbx
cmpl $0x44, %eax
je 0x3f65
cmpl $0x63, %eax
je 0x3f4c
cmpl $0x78, %eax
je 0x3f25
cmpl $0x6f, %eax
je 0x3f3b
cmpl $0x73, %eax
je 0x3f2d
cmpl $0x64, %eax
jne 0x3ee7
movl (%r14), %edi
movl %ebp, %esi
jmp 0x3f41
movl (%r14), %edi
movl %r15d, %esi
jmp 0x3f41
movq %r14, %rdi
callq 0x4060
addq $0x8, %r14
jmp 0x3ed4
movl (%r14), %edi
movl %r12d, %esi
callq 0x3fac
addq $0x4, %r14
jmp 0x3ed4
movsbl (%r14), %edi
xorl %eax, %eax
callq *0x28(%r13)
incl 0x81a8(%rip)            # 0xc104
addq $0x8, %r14
jmp 0x3ed4
movq (%r14), %rdi
movl %ebp, %esi
callq 0x4002
addq $0x8, %r14
jmp 0x3ed4
leaq 0x8395(%rip), %rax      # 0xc314
cmpl $0x1, (%rax)
jne 0x3f8a
xorl %eax, %eax
callq *0x40(%r13)
xorl %eax, %eax
callq *0x30(%r13)
leaq 0x889d(%rip), %rax      # 0xc834
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlputi
void mlputi (int i, int r)
{
  int q;
  static char hexdigits[] = "0123456789abcdef";

  if (i < 0)
    {
      i = -i;
      (*term.t_putchar) ('-');
    }
  q = i / r;

  if (q != 0)
    mlputi (q, r);

  (*term.t_putchar) (hexdigits[i % r]);
  ++ttcol;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
testl %edi, %edi
jns 0x3fc8
negl %ebp
leaq 0x87c0(%rip), %rcx      # 0xc780
pushq $0x2d
popq %rdi
xorl %eax, %eax
callq *0x28(%rcx)
movl %ebp, %eax
cltd
idivl %ebx
movl %edx, %ebp
testl %eax, %eax
je 0x3fdc
movl %eax, %edi
movl %ebx, %esi
callq 0x3fac
leaq 0x879d(%rip), %rcx      # 0xc780
movl %ebp, %eax
leaq 0x40e4(%rip), %rdx      # 0x80d0
movsbl (%rax,%rdx), %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x8109(%rip)            # 0xc104
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlputli
void mlputli (long l, int r)
{
  long q;

  if (l < 0)
    {
      l = -l;
      (*term.t_putchar) ('-');
    }
  q = l / r;

  if (q != 0)
    mlputli (q, r);

  (*term.t_putchar) ((int) (l % r) + '0');
  ++ttcol;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jns 0x4022
negq %r14
leaq 0x8766(%rip), %rcx      # 0xc780
pushq $0x2d
popq %rdi
xorl %eax, %eax
callq *0x28(%rcx)
movslq %ebx, %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rdx, %r14
testq %rax, %rax
je 0x403f
movq %rax, %rdi
movl %ebx, %esi
callq 0x4002
leaq 0x873a(%rip), %rcx      # 0xc780
addl $0x30, %r14d
movl %r14d, %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x80ac(%rip)            # 0xc104
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/file.c
// Function: filename
int filename (int f, int n)
{
  WINDOW *wp;
  char fname[NFILEN];
  int s;

  if ((s = mlreply ("Name: ", fname, NFILEN)) == ABORT)
    return (s);
  if (s == FALSE)
    strncpy (curbp->b_fname, "", 1);
  else
    strncpy (curbp->b_fname, fname, NFILEN);
  wp = wheadp;			/* update mode lines */
  while (wp != NULL)
    {
      if (wp->w_bufp == curbp)
	wp->w_flag |= WFMODE;
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
leaq 0x39f2(%rip), %rdi      # 0x81f8
movq %rsp, %rsi
pushq $0x50
popq %rdx
callq 0x3e7b
cmpl $0x2, %eax
je 0x4861
testl %eax, %eax
jne 0x482a
leaq 0x8017(%rip), %rax      # 0xc838
movq (%rax), %rbx
movb $0x0, 0x33(%rbx)
jmp 0x4843
leaq 0x8007(%rip), %rax      # 0xc838
movq (%rax), %rbx
leaq 0x33(%rbx), %rdi
movq %rsp, %rsi
pushq $0x50
popq %rdx
callq 0x2060
leaq 0x8016(%rip), %rcx      # 0xc860
pushq $0x1
popq %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x4861
cmpq %rbx, 0x8(%rcx)
jne 0x484d
orb $0x10, 0x3b(%rcx)
jmp 0x484d
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/line.c
// Function: kinsert
int kinsert (int c)
{
  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 0x789d(%rip), %rsi      # 0xc818
cmpq 0x789e(%rip), %rsi      # 0xc820
jne 0x4f9e
testq %rsi, %rsi
je 0x4fa7
movq 0x7880(%rip), %rdi      # 0xc810
addq $0x400, %rsi            # imm = 0x400
callq 0x2170
jmp 0x4fb1
movq 0x786b(%rip), %rax      # 0xc810
jmp 0x4fcf
movl $0x400, %edi            # imm = 0x400
callq 0x2140
testq %rax, %rax
je 0x4fe2
movq %rax, 0x7853(%rip)      # 0xc810
addq $0x400, 0x7858(%rip) # imm = 0x400
movq 0x7849(%rip), %rsi      # 0xc818
leaq 0x1(%rsi), %rcx
movq %rcx, 0x783e(%rip)      # 0xc818
movb %bl, (%rax,%rsi)
pushq $0x1
popq %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0x4fe0
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/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)
	{
	  thisflag = 0;
	  status = (*ktp->k_fp) (f, n);
	  lastflag = thisflag;
	  return (status);
	}
      ++ktp;
    }

  if ((c >= 0x20 && c <= 0x7E)	/* Self inserting */
      || (c >= 0xA0 && c <= 0xFE))
    {
      if (n <= 0)
	{			/* Fenceposts */
	  lastflag = 0;
	  return (n < 0 ? FALSE : TRUE);
	}
      thisflag = 0;		/* For the future */

      status = linsert (n, c);

      lastflag = thisflag;
      return (status);
    }
  mlwrite ("\007[Key not bound]"); /* complain */
  lastflag = 0;			/* Fake last flags */
  return (FALSE);
}

// Assembly:
pushq %rbx
movl %edi, %eax
leaq 0x6d82(%rip), %rdi      # 0xc328
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x55cd
movswl -0x8(%rdi), %r8d
addq $0x10, %rdi
cmpl %eax, %r8d
jne 0x55a6
andl $0x0, 0x72a5(%rip)      # 0xc868
movl %esi, %edi
movl %edx, %esi
xorl %eax, %eax
callq *%rcx
jmp 0x55f1
movl %eax, %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
addl $-0x20, %ecx
cmpl $0x5e, %ecx
ja 0x55ff
testl %edx, %edx
jle 0x5618
andl $0x0, 0x7280(%rip)      # 0xc868
movl %edx, %edi
movl %eax, %esi
callq 0x4b10
movl 0x7271(%rip), %ecx      # 0xc868
movl %ecx, 0x7243(%rip)      # 0xc840
jmp 0x5628
leaq 0x2d7e(%rip), %rdi      # 0x8384
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3e83
andl $0x0, 0x722a(%rip)      # 0xc840
jmp 0x5626
andl $0x0, 0x7221(%rip)      # 0xc840
xorl %ebx, %ebx
testl %edx, %edx
sete %bl
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/main.c
// Function: quickexit
int quickexit (int f, int n)
{
  BUFFER *bp;			/* scanning pointer to buffers */

  bp = bheadp;
  while (bp != NULL)
    {
      if ((bp->b_flag & BFCHG) != 0 /* Changed */
	  && (bp->b_flag & BFTEMP) == 0)
	{			/* Real */
	  curbp = bp;		/* make that buffer current */
	  mlwrite ("[Saving %s]", (int*)bp->b_fname);
	  filesave (f, n);
	}
      bp = bp->b_bufp;		/* on to the next buffer */
    }
  return quit (f, n);		/* conditionally quit */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
leaq 0x71de(%rip), %r15      # 0xc870
leaq 0x2cfc(%rip), %r14      # 0x8395
movq (%r15), %r15
testq %r15, %r15
je 0x56cd
movb 0x32(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x5699
movq %r15, 0x7186(%rip)      # 0xc838
leaq 0x33(%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3e83
movl %ebx, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x478c
jmp 0x5699
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x56de
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/main.c
// Function: extendedcmd
int extendedcmd (int f, int n)
{
  int (*cmd)();
  int c;

  c = getctl();
  switch (c)
    {
    case 'A': cmd = backline; break;
    case 'B': cmd = forwline; break;
    case 'C': cmd = forwchar; break;
    case 'D': cmd = backchar; break;
    case 'H': cmd = gotobob; break;
    case 'W': cmd = gotoeob; break;
    case '5': cmd = backpage; getctl(); break;
    case '6': cmd = forwpage; getctl(); break;
    case '7': cmd = gotobob; getctl(); break;
    case '8': cmd = gotoeob; getctl(); break;
    default: mlwrite ("\007[Key not bound]");
      return (FALSE);
    }
  return cmd(f, n);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x5657
leal -0x35(%rax), %ecx
cmpl $0x13, %ecx
ja 0x58c2
leaq 0x2a69(%rip), %rax      # 0x8314
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
callq 0x5657
leaq -0x311e(%rip), %rcx     # 0x27a2
jmp 0x592a
cmpl $0x57, %eax
je 0x58ec
leaq 0x2ab6(%rip), %rdi      # 0x8384
xorl %eax, %eax
callq 0x3e83
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq -0x358e(%rip), %rcx     # 0x2357
jmp 0x592a
callq 0x5657
leaq -0x33fe(%rip), %rcx     # 0x24f5
jmp 0x592a
leaq -0x34b2(%rip), %rcx     # 0x244a
jmp 0x592a
callq 0x5657
leaq -0x3441(%rip), %rcx     # 0x24c9
jmp 0x592a
callq 0x5657
leaq -0x31eb(%rip), %rcx     # 0x272d
jmp 0x592a
leaq -0x3403(%rip), %rcx     # 0x251e
jmp 0x592a
leaq -0x3577(%rip), %rcx     # 0x23b3
movl %ebp, %edi
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/random.c
// Function: showcpos
int showcpos (int f, int n)
{
  LINE *clp;
  long nch, nbc;
  int cbo, cac, ratio, col;

  clp = lforw (curbp->b_linep);	/* Grovel the data */
  cbo = 0;
  nch = 0;
  nbc = 0;
  cac = 0;
  for (;;)
    {
      if (clp == curwp->w_dotp && cbo == curwp->w_doto)
	{
	  nbc = nch;
	  if (cbo == llength (clp))
	    cac = '\n';
	  else
	    cac = lgetc (clp, cbo);
	}
      if (cbo == llength (clp))
	{
	  if (clp == curbp->b_linep)
	    break;
	  clp = lforw (clp);
	  cbo = 0;
	}
      else
	++cbo;
      ++nch;
    }
  col = getccol (FALSE);       /* Get real column */
  ratio = 0;		       /* Ratio before dot */
  if (nch != 0)
    ratio = (100L * nbc) / nch;
  mlwrite ("Char: %c (0%o, %d, 0x%x)  point=%D of %D(%d%%) column %d",
	   ((cac > 31) && (cac < 128) ? cac : 32),
	   cac, cac, cac, nbc + 1, nch, ratio, col);
  return (TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6ed4(%rip), %rax      # 0xc838
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
leaq 0x6ed3(%rip), %rdx      # 0xc848
movq (%rdx), %rdx
movq 0x18(%rdx), %rsi
xorl %r12d, %r12d
pushq $0xa
popq %rdi
xorl %ebx, %ebx
xorl %r8d, %r8d
xorl %r14d, %r14d
cmpq %rsi, %rcx
jne 0x59ad
movslq %r8d, %r9
cmpq %r9, 0x20(%rdx)
jne 0x59ad
movq %r12, %rbx
movl %edi, %r14d
cmpl 0x14(%rcx), %r8d
je 0x59ad
movzbl 0x18(%rcx,%r9), %r14d
movq %r12, %rbx
cmpl 0x14(%rcx), %r8d
jne 0x59c0
cmpq %rax, %rcx
je 0x59c8
movq (%rcx), %rcx
xorl %r8d, %r8d
jmp 0x59c3
incl %r8d
incq %r12
jmp 0x598a
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x5a2e
movl %eax, %r10d
testq %r12, %r12
je 0x59e6
imulq $0x64, %rbx, %rax
cqto
idivq %r12
movq %rax, %r15
leal -0x20(%r14), %eax
cmpl $0x60, %eax
pushq $0x20
popq %rsi
cmovbl %r14d, %esi
incq %rbx
subq $0x8, %rsp
leaq 0x2a15(%rip), %rdi      # 0x8417
movl %r14d, %edx
movl %r14d, %ecx
movl %r14d, %r8d
movq %rbx, %r9
xorl %eax, %eax
pushq %r10
pushq %r15
pushq %r12
callq 0x3e83
addq $0x20, %rsp
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/random.c
// Function: twiddle
int twiddle (int f, int n)
{
  LINE *dotp;
  int doto, cl, cr;

  dotp = curwp->w_dotp;
  doto = curwp->w_doto;
  if (doto == llength (dotp) && --doto < 0)
    return (FALSE);
  cr = lgetc (dotp, doto);
  if (--doto < 0)
    return (FALSE);
  cl = lgetc (dotp, doto);
  lputc (dotp, doto + 0, cr);
  lputc (dotp, doto + 1, cl);
  lchange (WFEDIT);
  return (TRUE);
}

// Assembly:
leaq 0x6dac(%rip), %rax      # 0xc848
movq (%rax), %rcx
movq 0x18(%rcx), %rax
movl 0x20(%rcx), %ecx
cmpl %ecx, 0x14(%rax)
jne 0x5ab1
testl %ecx, %ecx
jle 0x5ade
decl %ecx
testl %ecx, %ecx
jle 0x5ade
pushq %rax
movl %ecx, %edx
decl %ecx
movb 0x18(%rax,%rdx), %sil
movb 0x18(%rax,%rcx), %dil
movb %sil, 0x18(%rax,%rcx)
movb %dil, 0x18(%rax,%rdx)
pushq $0x4
popq %rdi
callq 0x4ad0
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/random.c
// Function: openline
int openline (int f, int n)
{
  int i, s;

  if (n < 0)
    return (FALSE);
  if (n == 0)
    return (TRUE);
  i = n;		       /* Insert newlines */
  do
    {
      s = lnewline ();
    }
  while (s == TRUE && --i);
  if (s == TRUE)	       /* Then back up overtop */
    s = backchar (f, n);       /* of them all */
  return (s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x5b85
je 0x5b89
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %r14
xorl %eax, %eax
callq 0x4d0a
cmpl $0x1, %eax
jne 0x5b73
leal 0x1(%r14), %ecx
cmpl %r14d, %ebx
movl %ecx, %r14d
jne 0x5b5b
cmpl $0x1, %eax
jne 0x5b8c
movl %ebp, %edi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2357
xorl %eax, %eax
jmp 0x5b8c
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/search.c
// Function: forwsearch
int forwsearch (int f, int n)
{
  int status=FALSE;

  if (n == 0)			/* resolve the repeat count */
    n = 1;
  if (n < 1)			/* search backwards */
    return (backsearch (f, -n));

  /* ask the user for the text of a pattern */
  if ((status = readpattern ("Search")) != TRUE)
    return (status);

  /* search for the pattern */
  while (n-- > 0)
    {
      if ((status = forscan (&pat[0], PTEND)) == FALSE)
	break;
    }

  /* and complain if not there */
  if (status == FALSE)
    mlwrite ("Not found");
  return (status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0x1, %esi
adcl $0x0, %ebx
testl %ebx, %ebx
jle 0x6018
leaq 0x24b9(%rip), %rdi      # 0x8483
callq 0x605d
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x600b
incl %ebx
pushq $0x1
popq %rbp
leaq 0x689e(%rip), %r14      # 0xc880
pushq $0x2
popq %r15
decl %ebx
testl %ebx, %ebx
jle 0x600b
movq %r14, %rdi
movl %r15d, %esi
callq 0x6107
testl %eax, %eax
jne 0x5fe6
leaq 0x2488(%rip), %rdi      # 0x848a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3e83
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
negl %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x602b
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/search.c
// Function: backsearch
int backsearch (int f, int n)
{
  int s;

  if (n == 0)			/* resolve null and negative arguments */
    n = 1;
  if (n < 1)
    return (forwsearch (f, -n));

  if ((s = readpattern("Reverse search")) != TRUE)/* get a pattern to search */
    return (s);

  return bsearch (f, n);	/* and go search for it */
}

// Assembly:
pushq %rbx
movl %esi, %ebx
cmpl $0x1, %esi
adcl $0x0, %ebx
testl %ebx, %ebx
jle 0x6051
leaq 0x2464(%rip), %rdi      # 0x84a3
callq 0x605d
cmpl $0x1, %eax
jne 0x605b
movl %ebx, %esi
popq %rbx
jmp 0x62d3
negl %ebx
movl %ebx, %esi
popq %rbx
jmp 0x5fb0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/search.c
// Function: readpattern
int readpattern (char *prompt)
{
  char tpat[NPAT + 20];
  int s;

  strncpy (tpat, prompt, NPAT-12); /* copy prompt to output string */
  strncat (tpat, " [", 3);	/* build new prompt string */
  expandp (&pat[0], &tpat[strlen (tpat)], NPAT / 2); /* add old pattern */
  strncat (tpat, "]<ESC>: ", 9);

  s = mlreplyt (tpat, tpat, NPAT, 27); /* Read pattern */

  if (s == TRUE)		/* Specified */
    strncpy (pat, tpat, NPAT);
  else if (s == FALSE && pat[0] != 0) /* CR, but old one */
    s = TRUE;

  return (s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
pushq $0x44
popq %rdx
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x20c0
xorl %ebp, %ebp
movb %bpl, 0x2(%rsp,%rax)
movw $0x5b20, (%rsp,%rax)    # imm = 0x5B20
movq %rbx, %rdi
callq 0x20c0
leaq (%rsp,%rax), %rsi
leaq 0x67e2(%rip), %r14      # 0xc880
pushq $0x28
popq %rdx
movq %r14, %rdi
callq 0x6441
movq %rbx, %rdi
callq 0x20c0
movabsq $0x203a3e4353453c5d, %rcx # imm = 0x203A3E4353453C5D
movq %rcx, (%rsp,%rax)
movb %bpl, 0x8(%rsp,%rax)
pushq $0x50
popq %rdx
pushq $0x1b
popq %rcx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3b58
testl %eax, %eax
je 0x60f5
cmpl $0x1, %eax
jne 0x60fe
leaq 0x679b(%rip), %rdi      # 0xc880
movq %rsp, %rsi
pushq $0x50
popq %rdx
callq 0x2060
pushq $0x1
popq %rax
jmp 0x60fe
xorl %eax, %eax
cmpb $0x0, (%r14)
setne %al
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/search.c
// Function: forwhunt
int forwhunt (int f, int n)
{
  int status=FALSE;

  /* resolve the repeat count */
  if (n == 0)
    n = 1;
  if (n < 1)			/* search backwards */
    return (backhunt (f, -n));

  /* Make sure a pattern exists */
  if (pat[0] == 0)
    {
      mlwrite ("No pattern set");
      return (FALSE);
    }
  /* search for the pattern */
  while (n-- > 0)
    {
      if ((status = forscan (&pat[0], PTEND)) == FALSE)
	break;
    }

  /* and complain if not there */
  if (status == FALSE)
    mlwrite ("Not found");
  return (status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
cmpl $0x1, %esi
adcl $0x0, %ebx
testl %ebx, %ebx
jle 0x6267
leaq 0x6644(%rip), %rax      # 0xc880
cmpb $0x0, (%rax)
je 0x6274
incl %ebx
movb $0x1, %cl
leaq 0x6634(%rip), %r14      # 0xc880
pushq $0x2
popq %rbp
decl %ebx
testl %ebx, %ebx
jle 0x627d
movq %r14, %rdi
movl %ebp, %esi
callq 0x6107
xorl %ecx, %ecx
testl %eax, %eax
jne 0x624f
jmp 0x6282
negl %ebx
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x629e
leaq 0x2219(%rip), %rdi      # 0x8494
jmp 0x6289
testb $0x1, %cl
je 0x6299
leaq 0x2201(%rip), %rdi      # 0x848a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3e83
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rbx
jmp 0x6292
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/search.c
// Function: backhunt
int backhunt (int f, int n)
{
  if (n == 0)			/* resolve null and negative arguments */
    n = 1;
  if (n < 1)
    return (forwhunt (f, -n));

  if (pat[0] == 0)		/* Make sure a pattern exists */
    {
      mlwrite ("No pattern set");
      return (FALSE);
    }
  return bsearch (f, n);	/* go search */
}

// Assembly:
cmpl $0x1, %esi
adcl $0x0, %esi
testl %esi, %esi
jle 0x62b9
leaq 0x65d1(%rip), %rax      # 0xc880
cmpb $0x0, (%rax)
je 0x62c0
jmp 0x62d3
negl %esi
jmp 0x6225
pushq %rax
leaq 0x21cc(%rip), %rdi      # 0x8494
xorl %eax, %eax
callq 0x3e83
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/window.c
// Function: enlargewind
int enlargewind (int f, int n)
{
  WINDOW *adjwp;
  LINE *lp;
  int i;

  if (n < 0)
    return (shrinkwind (f, -n));
  if (wheadp->w_wndp == NULL)
    {
      mlwrite ("Only one window");
      return (FALSE);
    }
  if ((adjwp = curwp->w_wndp) == NULL)
    {
      adjwp = wheadp;
      while (adjwp->w_wndp != curwp)
	adjwp = adjwp->w_wndp;
    }
  if (adjwp->w_ntrows <= n)
    {
      mlwrite ("Impossible change");
      return (FALSE);
    }
  if (curwp->w_wndp == adjwp)
    {				/* Shrink below */
      lp = adjwp->w_linep;
      for (i = 0; i < n && lp != adjwp->w_bufp->b_linep; ++i)
	lp = lforw (lp);
      adjwp->w_linep = lp;
      adjwp->w_toprow += n;
    }
  else
    {				/* Shrink above */
      lp = curwp->w_linep;
      for (i = 0; i < n && lback (lp) != curbp->b_linep; ++i)
	lp = lback (lp);
      curwp->w_linep = lp;
      curwp->w_toprow -= n;
    }
  curwp->w_ntrows += n;
  adjwp->w_ntrows -= n;
  curwp->w_flag |= WFMODE | WFHARD;
  adjwp->w_flag |= WFMODE | WFHARD;
  return (TRUE);
}

// Assembly:
testl %esi, %esi
js 0x6f36
pushq %rbx
leaq 0x598c(%rip), %rax      # 0xc860
movq (%rax), %rdi
cmpq $0x0, (%rdi)
je 0x6f3d
leaq 0x5964(%rip), %rax      # 0xc848
movq (%rax), %rax
movq (%rax), %rdx
movq %rdx, %rcx
testq %rdx, %rdx
jne 0x6efd
movq %rdi, %rcx
movq (%rdi), %rdi
cmpq %rax, %rdi
jne 0x6ef2
movsbl 0x39(%rcx), %edi
cmpl %esi, %edi
jle 0x6f46
cmpq %rcx, %rdx
je 0x6f58
movq 0x10(%rax), %r9
leaq 0x5923(%rip), %rdx      # 0xc838
movq (%rdx), %rdx
leal 0x1(%rsi), %edi
movq %r9, %r8
decl %edi
je 0x6f2c
movq 0x8(%r8), %r9
cmpq 0x28(%rdx), %r9
jne 0x6f1b
movq %r8, 0x10(%rax)
subb %sil, 0x38(%rax)
jmp 0x6f78
negl %esi
jmp 0x6f8f
leaq 0x178b(%rip), %rdi      # 0x86cf
jmp 0x6f4d
leaq 0x1792(%rip), %rdi      # 0x86df
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3e83
jmp 0x6f8b
leaq 0x10(%rcx), %rdx
leal 0x1(%rsi), %edi
movq (%rdx), %rdx
decl %edi
je 0x6f70
movq 0x8(%rcx), %r8
cmpq 0x28(%r8), %rdx
jne 0x6f5f
movq %rdx, 0x10(%rcx)
addb %sil, 0x38(%rcx)
addb %sil, 0x39(%rax)
subb %sil, 0x39(%rcx)
orb $0x18, 0x3b(%rax)
orb $0x18, 0x3b(%rcx)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/window.c
// Function: shrinkwind
int shrinkwind (int f, int n)
{
  WINDOW *adjwp;
  LINE *lp;
  int i;

  if (n < 0)
    return (enlargewind (f, -n));
  if (wheadp->w_wndp == NULL)
    {
      mlwrite ("Only one window");
      return (FALSE);
    }
  if ((adjwp = curwp->w_wndp) == NULL)
    {
      adjwp = wheadp;
      while (adjwp->w_wndp != curwp)
	adjwp = adjwp->w_wndp;
    }
  if (curwp->w_ntrows <= n)
    {
      mlwrite ("Impossible change");
      return (FALSE);
    }
  if (curwp->w_wndp == adjwp)
    {				/* Grow below */
      lp = adjwp->w_linep;
      for (i = 0; i < n && lback (lp) != adjwp->w_bufp->b_linep; ++i)
	lp = lback (lp);
      adjwp->w_linep = lp;
      adjwp->w_toprow -= n;
    }
  else
    {				/* Grow above */
      lp = curwp->w_linep;
      for (i = 0; i < n && lp != curbp->b_linep; ++i)
	lp = lforw (lp);
      curwp->w_linep = lp;
      curwp->w_toprow += n;
    }
  curwp->w_ntrows -= n;
  adjwp->w_ntrows += n;
  curwp->w_flag |= WFMODE | WFHARD;
  adjwp->w_flag |= WFMODE | WFHARD;
  return (TRUE);
}

// Assembly:
testl %esi, %esi
js 0x6ffb
pushq %rbx
leaq 0x58c5(%rip), %rax      # 0xc860
movq (%rax), %rdx
cmpq $0x0, (%rdx)
je 0x7002
leaq 0x589d(%rip), %rax      # 0xc848
movq (%rax), %rax
movq (%rax), %rdi
movq %rdi, %rcx
testq %rdi, %rdi
jne 0x6fc4
movq %rdx, %rcx
movq (%rdx), %rdx
cmpq %rax, %rdx
jne 0x6fb9
movsbl 0x39(%rax), %edx
cmpl %esi, %edx
jle 0x700b
cmpq %rcx, %rdi
je 0x701d
leaq 0x10(%rax), %rdi
leaq 0x585c(%rip), %r8       # 0xc838
movq (%r8), %r8
leal 0x1(%rsi), %r9d
movq (%rdi), %rdi
decl %r9d
je 0x6ff1
cmpq 0x28(%r8), %rdi
jne 0x6fe3
movq %rdi, 0x10(%rax)
addb %sil, 0x38(%rax)
jmp 0x7041
negl %esi
jmp 0x6ec8
leaq 0x16c6(%rip), %rdi      # 0x86cf
jmp 0x7012
leaq 0x16cd(%rip), %rdi      # 0x86df
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3e83
jmp 0x7056
movq 0x10(%rcx), %r9
leal 0x1(%rsi), %edi
movq %r9, %r8
decl %edi
je 0x7039
movq 0x8(%r8), %r9
movq 0x8(%rcx), %r10
cmpq 0x28(%r10), %r9
jne 0x7024
movq %r8, 0x10(%rcx)
subb %sil, 0x38(%rcx)
subb %sil, %dl
movb %dl, 0x39(%rax)
addb %sil, 0x39(%rcx)
orb $0x18, 0x3b(%rax)
orb $0x18, 0x3b(%rcx)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: backword
int backword (int f, int n)
{
  if (n < 0)
    return (forwword (f, -n));
  if (backchar (FALSE, 1) == FALSE)
    return (FALSE);
  while (n--)
    {
      while (inword () == FALSE)
	{
	  if (backchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
      while (inword () != FALSE)
	{
	  if (backchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
    }
  return (forwchar (FALSE, 1));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x7134
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x2357
testl %eax, %eax
je 0x712b
pushq $0x1
popq %rbp
subl $0x1, %ebx
jb 0x7143
callq 0x74a9
testl %eax, %eax
jne 0x7120
xorl %edi, %edi
movl %ebp, %esi
callq 0x2357
testl %eax, %eax
jne 0x70fb
jmp 0x712b
xorl %edi, %edi
movl %ebp, %esi
callq 0x2357
testl %eax, %eax
je 0x712b
callq 0x74a9
testl %eax, %eax
jne 0x7113
jmp 0x70f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
negl %ebx
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7153
pushq $0x1
popq %rsi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x23b3
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: forwword
int forwword (int f, int n)
{
  if (n < 0)
    return (backword (f, -n));
  while (n--)
    {
      while (inword () != FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
      while (inword () == FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
js 0x719b
pushq $0x1
popq %rbp
subl $0x1, %ebx
jb 0x71a8
callq 0x74a9
testl %eax, %eax
je 0x7190
xorl %r14d, %r14d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
jne 0x7165
jmp 0x71ab
xorl %r14d, %r14d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
je 0x71ab
callq 0x74a9
testl %eax, %eax
je 0x7180
jmp 0x7160
negl %ebx
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x70dc
movl %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: upperword
int upperword (int f, int n)
{
  int c;

  if (n < 0)
    return (FALSE);
  while (n--)
    {
      while (inword () == FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
      while (inword () != FALSE)
	{
	  c = lgetc (curwp->w_dotp, curwp->w_doto);
	  if (c >= 'a' && c <= 'z')
	    {
	      c -= 'a' - 'A';
	      lputc (curwp->w_dotp, curwp->w_doto, c);
	      lchange (WFHARD);
	    }
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x7232
movl %esi, %ebx
pushq $0x1
popq %rbp
leaq 0x567d(%rip), %r12      # 0xc848
pushq $0x8
popq %r14
subl $0x1, %ebx
jb 0x7241
callq 0x74a9
testl %eax, %eax
jne 0x7227
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
jne 0x71d4
jmp 0x7235
movq (%r12), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movb 0x18(%rax,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x7217
addb $-0x20, %dl
movb %dl, 0x18(%rax,%rcx)
movl %r14d, %edi
callq 0x4ad0
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
je 0x7235
callq 0x74a9
testl %eax, %eax
jne 0x71ef
jmp 0x71cf
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r15d
jmp 0x7235
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: lowerword
int lowerword (int f, int n)
{
  int c;

  if (n < 0)
    return (FALSE);
  while (n--)
    {
      while (inword () == FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
      while (inword () != FALSE)
	{
	  c = lgetc (curwp->w_dotp, curwp->w_doto);
	  if (c >= 'A' && c <= 'Z')
	    {
	      c += 'a' - 'A';
	      lputc (curwp->w_dotp, curwp->w_doto, c);
	      lchange (WFHARD);
	    }
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x72c5
movl %esi, %ebx
pushq $0x1
popq %rbp
leaq 0x55ea(%rip), %r12      # 0xc848
pushq $0x8
popq %r14
subl $0x1, %ebx
jb 0x72d4
callq 0x74a9
testl %eax, %eax
jne 0x72ba
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
jne 0x7267
jmp 0x72c8
movq (%r12), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movb 0x18(%rax,%rcx), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x72aa
orb $0x20, %dl
movb %dl, 0x18(%rax,%rcx)
movl %r14d, %edi
callq 0x4ad0
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
je 0x72c8
callq 0x74a9
testl %eax, %eax
jne 0x7282
jmp 0x7262
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r15d
jmp 0x72c8
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: capword
int capword (int f, int n)
{
  int c;

  if (n < 0)
    return (FALSE);
  while (n--)
    {
      while (inword () == FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	}
      if (inword () != FALSE)
	{
	  c = lgetc (curwp->w_dotp, curwp->w_doto);
	  if (c >= 'a' && c <= 'z')
	    {
	      c -= 'a' - 'A';
	      lputc (curwp->w_dotp, curwp->w_doto, c);
	      lchange (WFHARD);
	    }
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	  while (inword () != FALSE)
	    {
	      c = lgetc (curwp->w_dotp, curwp->w_doto);
	      if (c >= 'A' && c <= 'Z')
		{
		  c += 'a' - 'A';
		  lputc (curwp->w_dotp, curwp->w_doto, c);
		  lchange (WFHARD);
		}
	      if (forwchar (FALSE, 1) == FALSE)
		return (FALSE);
	    }
	}
    }
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x737c
movl %esi, %ebx
pushq $0x1
popq %rbp
leaq 0x5553(%rip), %r12      # 0xc848
pushq $0x8
popq %r14
subl $0x1, %ebx
jb 0x738b
callq 0x74a9
testl %eax, %eax
jne 0x731d
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
jne 0x7302
jmp 0x737f
movq (%r12), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movb 0x18(%rax,%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x7345
addb $-0x20, %dl
movb %dl, 0x18(%rax,%rcx)
movl %r14d, %edi
callq 0x4ad0
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
je 0x737f
callq 0x74a9
testl %eax, %eax
je 0x72f9
movq (%r12), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movb 0x18(%rax,%rcx), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x7345
orb $0x20, %dl
jmp 0x7339
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %r15d
jmp 0x737f
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: delfword
int delfword (int f, int n)
{
  LINE *dotp;
  int size, doto;

  if (n < 0)
    return (FALSE);
  dotp = curwp->w_dotp;
  doto = curwp->w_doto;
  size = 0;
  while (n--)
    {
      while (inword () != FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	  ++size;
	}
      while (inword () == FALSE)
	{
	  if (forwchar (FALSE, 1) == FALSE)
	    return (FALSE);
	  ++size;
	}
    }
  curwp->w_dotp = dotp;
  curwp->w_doto = doto;
  return (ldelete (size, TRUE));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x73f5
movl %esi, %ebx
leaq 0x54a0(%rip), %r12      # 0xc848
movq (%r12), %rax
movq 0x18(%rax), %r13
movq 0x20(%rax), %r15
xorl %ebp, %ebp
pushq $0x1
popq %r14
subl $0x1, %ebx
jb 0x7406
callq 0x74a9
testl %eax, %eax
je 0x73ea
xorl %edi, %edi
movl %r14d, %esi
callq 0x23b3
testl %eax, %eax
je 0x73f5
incl %ebp
jmp 0x73bf
xorl %edi, %edi
movl %r14d, %esi
callq 0x23b3
testl %eax, %eax
je 0x73f5
incl %ebp
callq 0x74a9
testl %eax, %eax
je 0x73da
jmp 0x73ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
movq %r13, 0x18(%rax)
movslq %r15d, %rcx
movq %rcx, 0x20(%rax)
pushq $0x1
popq %rsi
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4dec
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: delbword
int delbword (int f, int n)
{
  int size;

  if (n < 0)
    return (FALSE);
  if (backchar (FALSE, 1) == FALSE)
    return (FALSE);
  size = 0;
  while (n--)
    {
      while (inword () == FALSE)
	{
	  if (backchar (FALSE, 1) == FALSE)
	    return (FALSE);
	  ++size;
	}
      while (inword () != FALSE)
	{
	  if (backchar (FALSE, 1) == FALSE)
	    return (FALSE);
	  ++size;
	}
    }
  if (forwchar (FALSE, 1) == FALSE)
    return (FALSE);
  return (ldelete (size, TRUE));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x74a2
movl %esi, %ebp
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x2357
testl %eax, %eax
je 0x74a2
pushq $0x1
popq %r14
subl $0x1, %ebp
jb 0x7486
callq 0x74a9
testl %eax, %eax
jne 0x747b
xorl %edi, %edi
movl %r14d, %esi
callq 0x2357
testl %eax, %eax
je 0x74a2
incl %ebx
jmp 0x7450
xorl %edi, %edi
movl %r14d, %esi
callq 0x2357
testl %eax, %eax
je 0x74a2
incl %ebx
callq 0x74a9
testl %eax, %eax
jne 0x746b
jmp 0x744b
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x23b3
testl %eax, %eax
je 0x74a2
pushq $0x1
popq %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x4dec
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/word.c
// Function: inword
int inword ()
{
  int c;

  if (curwp->w_doto == llength (curwp->w_dotp))
    return (FALSE);
  c = lgetc (curwp->w_dotp, curwp->w_doto);
  if (c >= 'a' && c <= 'z')
    return (TRUE);
  if (c >= 'A' && c <= 'Z')
    return (TRUE);
  if (c >= '0' && c <= '9')
    return (TRUE);
  if (c == '$' || c == '_')	/* For identifiers */
    return (TRUE);
  return (FALSE);
}

// Assembly:
leaq 0x5398(%rip), %rax      # 0xc848
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movslq 0x14(%rcx), %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x74f3
movb 0x18(%rcx,%rdx), %cl
leal -0x30(%rcx), %edx
pushq $0x1
popq %rax
cmpb $0xa, %dl
jb 0x74f3
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x1a, %dl
jb 0x74f3
cmpb $0x5f, %cl
sete %al
cmpb $0x24, %cl
sete %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/rikuu[P]kermit/kermit-color.c
// Function: color_stats
static void color_stats(const km_multicolor_t *colors, const size_t n_reads)
{
	size_t uncolored=0, ones=0, twos=0, multis=0;
	for (size_t i = 0; i < n_reads; i++) {
		if (colors[i].n == 0) uncolored++;
		else if (colors[i].n == 1) ones++;
		else if (colors[i].n == 2) twos++;
		else multis++;
	}
	fprintf(stderr, "[M::%s] %zu ones, %zu twos, %zu multis, %zu uncolored\n", __func__, ones, twos, multis, uncolored);
}

// Assembly:
pushq %rax
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
subq $0x1, %rsi
jb 0x7d7f
movq (%rdi), %rdx
cmpq $0x2, %rdx
je 0x7d71
cmpq $0x1, %rdx
je 0x7d6c
testq %rdx, %rdx
jne 0x7d76
incq %rax
jmp 0x7d79
incq %rcx
jmp 0x7d79
incq %r8
jmp 0x7d79
incq %r9
addq $0x18, %rdi
jmp 0x7d4d
movq 0x5272(%rip), %rdx      # 0xcff8
movq (%rdx), %rdi
movq %rax, (%rsp)
leaq 0x1dac(%rip), %rsi      # 0x9b40
leaq 0x1ddc(%rip), %rdx      # 0x9b77
xorl %eax, %eax
callq 0x1100
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/rikuu[P]kermit/kermit-color.c
// Function: km_align_reference
km_multicolor_t *km_align_reference(km_idx_t *idx, size_t n_reads, int unicolor)
{
	km_multicolor_t *colors = (km_multicolor_t*) calloc(n_reads, sizeof(km_multicolor_t));
	for (size_t i = 0; i < idx->d->n_seq; i++) {
		km_target_t *target = &idx->targets[i];
		for (size_t j = 0; j < target->n_bins; j++) {
			const uint64_t color = unicolor ? (i << 16) : (i << 16 | (j + 1));
			for (size_t k = 0; k < target->bins[j].n; k++) {
				int32_t id = target->bins[j].a[k].qn;
				if (id == -1 || id >= (int32_t) n_reads || (colors[id].n > 0 && colors[id].a[colors[id].n - 1] == color)) continue;
				kv_push(uint64_t, colors[id], color);
			}
		}
	}
	color_stats(colors, n_reads);
	return colors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x10d0
movq %rbx, %rsi
movq %rax, %r12
xorl %edx, %edx
movq %rax, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movl (%rax), %eax
cmpq %rax, %rdx
jae 0x7ef6
movq %rdx, %rdi
shlq $0x4, %rdi
addq 0x10(%rcx), %rdi
movq %rdx, 0x18(%rsp)
shlq $0x10, %rdx
movq %rdx, 0x20(%rsp)
xorl %eax, %eax
movq %rdi, 0x40(%rsp)
movl (%rdi), %ecx
cmpq %rcx, %rax
jae 0x7ee9
leaq 0x1(%rax), %rcx
cmpl $0x0, 0xc(%rsp)
movl $0x0, %r8d
movq %rcx, 0x28(%rsp)
cmoveq %rcx, %r8
orq 0x20(%rsp), %r8
imulq $0x18, %rax, %r13
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x8(%rdi), %rcx
leaq (%rcx,%r13), %rax
cmpq (%rcx,%r13), %rbx
jae 0x7edf
movq 0x10(%rax), %rax
movslq (%rax,%rbp), %rax
cmpl $-0x1, %eax
sete %cl
cmpl %esi, %eax
setge %dl
orb %cl, %dl
jne 0x7ed3
imulq $0x18, %rax, %rax
leaq (%r12,%rax), %r15
movq (%r12,%rax), %r14
testq %r14, %r14
je 0x7e84
movq 0x10(%r15), %rax
cmpq %r8, -0x8(%rax,%r14,8)
je 0x7ed3
cmpq 0x8(%r15), %r14
jne 0x7ec4
leaq (%r14,%r14), %rsi
testq %r14, %r14
pushq $0x2
popq %rax
cmoveq %rax, %rsi
movq %rsi, 0x8(%r15)
movq 0x10(%r15), %rdi
shlq $0x3, %rsi
movq %r8, %r12
callq 0x1160
movq %r12, %r8
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %r12
movq %rax, 0x10(%r15)
jmp 0x7ec8
movq 0x10(%r15), %rax
leaq 0x1(%r14), %rcx
movq %rcx, (%r15)
movq %r8, (%rax,%r14,8)
incq %rbx
addq $0xc, %rbp
jmp 0x7e3f
movq 0x28(%rsp), %rax
jmp 0x7e0f
movq 0x18(%rsp), %rdx
incq %rdx
jmp 0x7ddb
movq %r12, %rdi
callq 0x7d42
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_07/fgetc.c
// Function: main
int main(int argc, char *argv[])
{
	size_t size = BUFSIZ;
	char c;
	int ret;

        if (argc > 1)
		size = atoi(argv[1]);
	if (size <= 1) {
                fprintf(stderr, "invalid size, must be greater than 1\n");
                return -1;
	}
	fprintf(stderr, "set buffer size to %ld\n", size);

	ret = setvbuf(stdin, NULL, _IOFBF, size);
	if (ret) {
		fprintf(stderr, "setvbuf error for stdin\n");
		return -1;
	}
	ret = setvbuf(stdout, NULL, _IOFBF, size);
	if (ret) {
		fprintf(stderr, "setvbuf error for stdout\n");
		return -1;
	}

	while (!feof(stdin)) {
		/* Read data from input file */
		ret = fgetc(stdin);
		if (ret == EOF) {
			if (ferror(stdin)) {
				fprintf(stderr, "error in reading\n");
				return -1;
			}
			break;
		}
		c = (char) ret;

		/* Write data to output file */
		ret = fputc(c, stdout);
		if (ret == EOF) {
			if (ferror(stdout)) {
				fprintf(stderr, "error in writing\n");
				return -1;
			}
			break;
		}
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x2000, %ebx           # imm = 0x2000
cmpl $0x2, %edi
jl 0x11f3
movq 0x8(%rsi), %rdi
callq 0x1090
cmpl $0x1, %eax
ja 0x11f0
movq 0x2e25(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe27(%rip), %rdi       # 0x2004
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbx
jmp 0x1294
movslq %eax, %rbx
movq 0x2dfe(%rip), %r14      # 0x3ff8
movq (%r14), %rdi
leaq 0xe26(%rip), %rsi       # 0x202a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq 0x2dc3(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x1080
testl %eax, %eax
jne 0x12a2
movq 0x2da1(%rip), %r12      # 0x3fd0
movq (%r12), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x1080
testl %eax, %eax
jne 0x12b3
xorl %ebx, %ebx
movq (%r15), %rdi
callq 0x1070
testl %eax, %eax
jne 0x1294
movq (%r15), %rdi
callq 0x1040
cmpl $-0x1, %eax
je 0x1288
movsbl %al, %edi
movq (%r12), %rsi
callq 0x1050
cmpl $-0x1, %eax
jne 0x1245
movq (%r12), %rdi
callq 0x1030
testl %eax, %eax
je 0x1294
movq (%r14), %rcx
leaq 0xe01(%rip), %rdi       # 0x2087
jmp 0x12ce
movq (%r15), %rdi
callq 0x1030
testl %eax, %eax
jne 0x12c4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rcx
leaq 0xd96(%rip), %rdi       # 0x2042
pushq $0x18
jmp 0x11df
movq (%r14), %rcx
leaq 0xd9e(%rip), %rdi       # 0x205b
pushq $0x19
jmp 0x11df
movq (%r14), %rcx
leaq 0xda7(%rip), %rdi       # 0x2075
pushq $0x11
jmp 0x11df