LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/util.c
// Function: fu_file_exists
int fu_file_exists(const char *path)
{
    struct stat sb;

    if (stat(path, &sb)) {
        if (errno != ENOENT) {
            fprintf(stderr, "Error stat()ing %s: %s\n", path, strerror(errno));
        }
        return FALSE;
    }

    if (sb.st_mode & (S_IFREG | S_IFLNK)) {
        return TRUE;
    }
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x21b0
cmpl $0x0, %eax
je 0x916e
callq 0x2060
cmpl $0x2, (%rax)
je 0x9165
movq 0x5ed3(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2280
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0x34e2(%rip), %rsi      # 0xc640
movb $0x0, %al
callq 0x21a0
movl $0x0, -0x4(%rbp)
jmp 0x918e
movl -0x88(%rbp), %eax
andl $0xa000, %eax           # imm = 0xA000
cmpl $0x0, %eax
je 0x9187
movl $0x1, -0x4(%rbp)
jmp 0x918e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/util.c
// Function: fu_sub_file_ext
char *fu_sub_file_ext(const char *path, const char *oldext, const char *newext)
{
    static char buf[PATH_MAX + 1];

    char *dot = strrchr(path, '.');

    if (dot && !strcmp(dot, oldext)) {
        if (dot - path + strlen(newext) > PATH_MAX) goto too_long;

        strncpy(buf, path, dot - path);
        strcpy(buf + (dot - path), newext);
    } else { // unrecognized or missing extension, just append extension
        if (strlen(path) + strlen(newext) > PATH_MAX) goto too_long;

        strcpy(buf, path);
        strcat(buf, newext);
    }

    return fu_strdup(buf);
 too_long:
    fprintf(stderr, "FUnit: the file name '%s' is too long\n", path);
    abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x2110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9249
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x9249
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jbe 0x920e
jmp 0x92a5
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
leaq 0x807c(%rip), %rdi      # 0x112a0
callq 0x2070
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
leaq 0x8065(%rip), %rdi      # 0x112a0
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
jmp 0x9293
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jbe 0x9273
jmp 0x92a5
movq -0x8(%rbp), %rsi
leaq 0x8022(%rip), %rdi      # 0x112a0
callq 0x2090
movq -0x18(%rbp), %rsi
leaq 0x8012(%rip), %rdi      # 0x112a0
callq 0x2250
leaq 0x8006(%rip), %rdi      # 0x112a0
callq 0x90c0
addq $0x30, %rsp
popq %rbp
retq
movq 0x5d4c(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x339e(%rip), %rsi      # 0xc658
movb $0x0, %al
callq 0x21a0
callq 0x2050
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/util.c
// Function: sb_ensure
void sb_ensure(struct StringBuffer *sb, size_t at_least)
{
    if (sb->cap >= sb->len + at_least) return;

    while (sb->cap < sb->len + at_least) sb->cap += sb->cap;

    sb->s = realloc(sb->s, sb->cap);
    if (!sb->s) abort(); // XXX or handle allocation better?
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jb 0x936b
jmp 0x93c9
jmp 0x936d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x939c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x936d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x93c9
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: main
int main(void)
{
  int n;
  char word[MAX_WORD_LEN];

  while (get_word(word, MAX_WORD_LEN) != EOF)
  {
    if (isalpha(word[0]))
    {
      if ((n = bin_search(word, keytab, NR_OF_KEYS)) >= 0)
      {
        keytab[n].count++;
      }
    }
  }

  for (size_t i = 0; i < NR_OF_KEYS; ++i)
  {
    if (keytab[i].count)
    {
      printf("%4d %s\n", keytab[i].count, keytab[i].word);
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x64, %esi
callq 0x1280
cmpl $-0x1, %eax
je 0x11fe
callq 0x1070
movq (%rax), %rax
movsbl -0x70(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x11fc
leaq -0x70(%rbp), %rdi
leaq 0x2e83(%rip), %rsi      # 0x4050
movl $0x21, %edx
callq 0x13c0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jl 0x11fa
movslq -0x8(%rbp), %rcx
leaq 0x2e66(%rip), %rax      # 0x4050
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x11fc
jmp 0x1192
movq $0x0, -0x78(%rbp)
cmpq $0x21, -0x78(%rbp)
jae 0x126d
movq -0x78(%rbp), %rcx
leaq 0x2e38(%rip), %rax      # 0x4050
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x125d
movq -0x78(%rbp), %rcx
leaq 0x2e20(%rip), %rax      # 0x4050
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
movq -0x78(%rbp), %rcx
leaq 0x2e0b(%rip), %rax      # 0x4050
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xe74(%rip), %rdi       # 0x20ca
movb $0x0, %al
callq 0x1030
jmp 0x125f
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x1206
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: bin_search
int bin_search(char *word, struct key arr[], int arr_len)
{
  int low = 0;
  int high = arr_len - 1;
  int mid;

  while (low <= high)
  {
    mid = (low + high) / 2;

    int cond = strcmp(word, arr[mid].word);
    if (cond < 0)
    {
      high = mid - 1;
    }
    else if (cond > 0)
    {
      low = mid + 1;
    }
    else
    {
      return mid;
    }
  }

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x1448
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1040
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x142b
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1446
cmpl $0x0, -0x2c(%rbp)
jle 0x143c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1444
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x144f
jmp 0x1446
jmp 0x13e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotoline
int gotoline (int f, int n)
{
  if (n < 1)		       /* if a bogus argument...then leave */
    return (FALSE);

  /* first, we go to the start of the buffer */
  curwp->w_dotp = lforw (curbp->b_linep);
  curwp->w_doto = 0;
  return (forwline (f, n - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x260d
movl $0x0, -0x4(%rbp)
jmp 0x264f
leaq 0xf254(%rip), %rax      # 0x11868
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
leaq 0xf253(%rip), %rax      # 0x11878
movq (%rax), %rax
movq %rcx, 0x18(%rax)
leaq 0xf245(%rip), %rax      # 0x11878
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
subl $0x1, %esi
callq 0x2660
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rsi
leaq 0x9dc6(%rip), %rdi      # 0xd00f
movl $0x10, %edx
callq 0x5940
movl %eax, -0x34(%rbp)
cmpl $0x1, %eax
je 0x3263
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3292
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x32a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3286
movl $0x0, -0x4(%rbp)
jmp 0x3292
movq -0x18(%rbp), %rdi
callq 0x2fb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rsi
leaq 0x9aa3(%rip), %rdi      # 0xd01c
movl $0x10, %edx
callq 0x5940
movl %eax, -0x34(%rbp)
cmpl $0x1, %eax
je 0x3593
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35bf
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x32a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x35b3
movl $0x1, -0x4(%rbp)
jmp 0x35bf
movq -0x18(%rbp), %rdi
callq 0x35d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x31(%rax), %eax
cmpl $0x0, %eax
je 0x3603
leaq 0x9a3a(%rip), %rdi      # 0xd02a
movb $0x0, %al
callq 0x5970
movl $0x0, -0x4(%rbp)
jmp 0x369b
movq -0x10(%rbp), %rdi
callq 0x36b0
movl %eax, -0x24(%rbp)
cmpl $0x1, %eax
je 0x361c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x369b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq $0x0, -0x18(%rbp)
leaq 0xe268(%rip), %rax      # 0x118a0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x365e
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x363f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3680
movq -0x20(%rbp), %rcx
leaq 0xe225(%rip), %rax      # 0x118a0
movq %rcx, (%rax)
jmp 0x368b
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rsi
leaq 0x98bb(%rip), %rdi      # 0xd044
movl $0x10, %edx
callq 0x5940
cmpl $0x1, %eax
je 0x37a4
movl $0x0, -0x4(%rbp)
jmp 0x3834
leaq 0xe0f5(%rip), %rax      # 0x118a0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37f3
movq -0x18(%rbp), %rax
leaq 0xe0a4(%rip), %rcx      # 0x11868
cmpq (%rcx), %rax
je 0x37e6
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x83, %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x37e4
jmp 0x377e
jmp 0x37e6
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x37b2
leaq 0xe06e(%rip), %rax      # 0x11868
movq (%rax), %rdi
addq $0x83, %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x2060
leaq 0xe05f(%rip), %rax      # 0x11878
movq (%rax), %rax
movsbl 0x3b(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x3b(%rax)
movb $0x0, %al
callq 0x3f90
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x5b9d
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x2d, %edi
leaq 0xbc18(%rip), %rcx      # 0x117b0
movb $0x0, %al
callq *0x28(%rcx)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5bb8
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x5b70
leaq 0xbbf1(%rip), %rax      # 0x117b0
movq 0x28(%rax), %rcx
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movslq %edx, %rdx
leaq 0xb54c(%rip), %rax      # 0x11120
movsbl (%rax,%rdx), %edi
movb $0x0, %al
callq *%rcx
movl 0xb532(%rip), %eax      # 0x11114
addl $0x1, %eax
movl %eax, 0xb529(%rip)      # 0x11114
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x5c31
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x2d, %edi
leaq 0xbb84(%rip), %rcx      # 0x117b0
movb $0x0, %al
callq *0x28(%rcx)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5c55
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5c00
leaq 0xbb54(%rip), %rax      # 0x117b0
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rsi
cqto
idivq %rsi
movl %edx, %edi
addl $0x30, %edi
movb $0x0, %al
callq *%rcx
movl 0xb498(%rip), %eax      # 0x11114
addl $0x1, %eax
movl %eax, 0xb48f(%rip)      # 0x11114
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x70(%rbp), %rsi
leaq 0x672a(%rip), %rdi      # 0xd2a6
movl $0x50, %edx
callq 0x5940
movl %eax, -0x74(%rbp)
cmpl $0x2, %eax
jne 0x6b99
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6c27
cmpl $0x0, -0x74(%rbp)
jne 0x6bc0
leaq 0xacc2(%rip), %rax      # 0x11868
movq (%rax), %rdi
addq $0x33, %rdi
leaq 0x6b78(%rip), %rsi      # 0xd72c
movl $0x1, %edx
callq 0x2060
jmp 0x6bdc
leaq 0xaca1(%rip), %rax      # 0x11868
movq (%rax), %rdi
addq $0x33, %rdi
leaq -0x70(%rbp), %rsi
movl $0x50, %edx
callq 0x2060
leaq 0xacad(%rip), %rax      # 0x11890
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c20
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0xac68(%rip), %rcx      # 0x11868
cmpq (%rcx), %rax
jne 0x6c13
movq -0x18(%rbp), %rax
movsbl 0x3b(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x3b(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6bea
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq 0x9e66(%rip), %rax      # 0x11848
cmpq 0x9e67(%rip), %rax      # 0x11850
jne 0x7a52
cmpq $0x0, 0x9e5d(%rip)      # 0x11850
jne 0x7a05
movl $0x400, %edi            # imm = 0x400
callq 0x2150
movq %rax, -0x10(%rbp)
jmp 0x7a23
movq 0x9e34(%rip), %rdi      # 0x11840
movq 0x9e3d(%rip), %rsi      # 0x11850
addq $0x400, %rsi            # imm = 0x400
callq 0x2180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7a33
movl $0x0, -0x4(%rbp)
jmp 0x7a7d
movq -0x10(%rbp), %rax
movq %rax, 0x9e02(%rip)      # 0x11840
movq 0x9e0b(%rip), %rax      # 0x11850
addq $0x400, %rax            # imm = 0x400
movq %rax, 0x9dfe(%rip)      # 0x11850
movl -0x8(%rbp), %eax
movb %al, %dl
movq 0x9de2(%rip), %rax      # 0x11840
movq 0x9de3(%rip), %rcx      # 0x11848
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x9dd5(%rip)      # 0x11848
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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x8e68(%rip), %rax      # 0x11350
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8547
movq -0x18(%rbp), %rax
movswl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x8539
movl $0x0, 0x938b(%rip)      # 0x11898
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 0x9370(%rip), %eax      # 0x11898
movl %eax, 0x9342(%rip)      # 0x11870
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x85d5
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x84ec
cmpl $0x20, -0x8(%rbp)
jl 0x8553
cmpl $0x7e, -0x8(%rbp)
jle 0x8565
cmpl $0xa0, -0x8(%rbp)
jl 0x85b6
cmpl $0xfe, -0x8(%rbp)
jg 0x85b6
cmpl $0x0, -0x10(%rbp)
jg 0x858a
movl $0x0, 0x92fb(%rip)      # 0x11870
movl -0x10(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x85d5
movl $0x0, 0x9304(%rip)      # 0x11898
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x7150
movl %eax, -0x1c(%rbp)
movl 0x92f0(%rip), %eax      # 0x11898
movl %eax, 0x92c2(%rip)      # 0x11870
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x85d5
leaq 0x4eb3(%rip), %rdi      # 0xd470
movb $0x0, %al
callq 0x5970
movl $0x0, 0x92a2(%rip)      # 0x11870
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x91fb(%rip), %rax      # 0x118a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x870b
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x86fe
movq -0x10(%rbp), %rax
movsbl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x86fe
movq -0x10(%rbp), %rax
movq %rax, 0x918d(%rip)      # 0x11868
movq -0x10(%rbp), %rsi
addq $0x33, %rsi
leaq 0x4d97(%rip), %rdi      # 0xd481
movb $0x0, %al
callq 0x5970
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movb $0x0, %al
callq 0x6a80
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x86a9
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x8720
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x8640
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x35, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x22, %eax
ja 0x8ade
movq -0x28(%rbp), %rax
leaq 0x498e(%rip), %rcx      # 0xd3c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x6216(%rip), %rax     # 0x2830
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x63f6(%rip), %rax     # 0x2660
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x6576(%rip), %rax     # 0x24f0
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x6676(%rip), %rax     # 0x2400
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x6313(%rip), %rax     # 0x2770
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x62c0(%rip), %rax     # 0x27d0
movq %rax, -0x18(%rbp)
jmp 0x8af5
leaq -0x5c6d(%rip), %rax     # 0x2e30
movq %rax, -0x18(%rbp)
callq 0x8640
jmp 0x8af5
leaq -0x5d9f(%rip), %rax     # 0x2d10
movq %rax, -0x18(%rbp)
callq 0x8640
jmp 0x8af5
leaq -0x6351(%rip), %rax     # 0x2770
movq %rax, -0x18(%rbp)
callq 0x8640
jmp 0x8af5
leaq -0x6303(%rip), %rax     # 0x27d0
movq %rax, -0x18(%rbp)
callq 0x8640
jmp 0x8af5
leaq 0x498b(%rip), %rdi      # 0xd470
movb $0x0, %al
callq 0x5970
movl $0x0, -0x4(%rbp)
jmp 0x8b06
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
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x8d03(%rip), %rax      # 0x11868
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq 0x8cdc(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
cmpq 0x18(%rcx), %rax
jne 0x8bed
movslq -0x24(%rbp), %rax
leaq 0x8cc8(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
cmpq 0x20(%rcx), %rax
jne 0x8bed
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x8bd6
movl $0xa, -0x28(%rbp)
jmp 0x8beb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x28(%rbp)
jmp 0x8bed
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x8c23
movq -0x10(%rbp), %rax
leaq 0x8c64(%rip), %rcx      # 0x11868
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x8c0f
jmp 0x8c3d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x8c2c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8b91
xorl %edi, %edi
callq 0x8cd0
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8c63
imulq $0x64, -0x20(%rbp), %rax
cqto
idivq -0x18(%rbp)
movl %eax, -0x2c(%rbp)
cmpl $0x1f, -0x28(%rbp)
jle 0x8c7a
cmpl $0x80, -0x28(%rbp)
jge 0x8c7a
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x8c84
movl $0x20, %eax
movl %eax, -0x34(%rbp)
jmp 0x8c84
movl -0x34(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x28(%rbp), %r8d
movq -0x20(%rbp), %r9
addq $0x1, %r9
movq -0x18(%rbp), %r11
movl -0x2c(%rbp), %r10d
movl -0x30(%rbp), %eax
leaq 0x4858(%rip), %rdi      # 0xd503
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x5970
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x8af3(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x8ae1(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x20(%rax), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x8dc4
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x8dc4
movl $0x0, -0x4(%rbp)
jmp 0x8e42
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x8df0
movl $0x0, -0x4(%rbp)
jmp 0x8e42
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, 0x18(%rax,%rcx)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x18(%rax,%rcx)
movl $0x4, %edi
callq 0x70b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8f3d
movl $0x0, -0x4(%rbp)
jmp 0x8f9a
cmpl $0x0, -0xc(%rbp)
jne 0x8f4c
movl $0x1, -0x4(%rbp)
jmp 0x8f9a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movb $0x0, %al
callq 0x7540
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
jne 0x8f79
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x8f52
cmpl $0x1, -0x14(%rbp)
jne 0x8f94
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x2400
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x97e2
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x97fa
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x9870
movl %eax, -0x4(%rbp)
jmp 0x985f
leaq 0x3d6e(%rip), %rdi      # 0xd56f
callq 0x98e0
movl %eax, -0x10(%rbp)
cmpl $0x1, %eax
je 0x9816
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x985f
jmp 0x9818
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x9845
leaq 0x8081(%rip), %rdi      # 0x118b0
movl $0x2, %esi
callq 0x99b0
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0x9843
jmp 0x9845
jmp 0x9818
cmpl $0x0, -0x10(%rbp)
jne 0x9859
leaq 0x3d24(%rip), %rdi      # 0xd576
movb $0x0, %al
callq 0x5970
movl -0x10(%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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x988b
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x98a3
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x97c0
movl %eax, -0x4(%rbp)
jmp 0x98cd
leaq 0x3ce5(%rip), %rdi      # 0xd58f
callq 0x98e0
movl %eax, -0x10(%rbp)
cmpl $0x1, %eax
je 0x98bf
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x98cd
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x9cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x44, %edx
callq 0x2060
leaq -0x70(%rbp), %rdi
leaq 0x3c92(%rip), %rsi      # 0xd59e
movl $0x3, %edx
callq 0x2100
leaq -0x70(%rbp), %rdi
callq 0x20c0
leaq -0x70(%rbp), %rsi
addq %rax, %rsi
leaq 0x7f83(%rip), %rdi      # 0x118b0
movl $0x28, %edx
callq 0x9f20
leaq -0x70(%rbp), %rdi
leaq 0x3c5f(%rip), %rsi      # 0xd5a1
movl $0x9, %edx
callq 0x2100
leaq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x50, %edx
movl $0x1b, %ecx
callq 0x53e0
movl %eax, -0x74(%rbp)
cmpl $0x1, -0x74(%rbp)
jne 0x9983
leaq -0x70(%rbp), %rsi
leaq 0x7f39(%rip), %rdi      # 0x118b0
movl $0x50, %edx
callq 0x2060
jmp 0x99a1
cmpl $0x0, -0x74(%rbp)
jne 0x999f
leaq 0x7f20(%rip), %rax      # 0x118b0
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x999f
movl $0x1, -0x74(%rbp)
jmp 0x99a1
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x9ba2
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x9bba
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x9c40
movl %eax, -0x4(%rbp)
jmp 0x9c29
leaq 0x7cef(%rip), %rax      # 0x118b0
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9be0
leaq 0x39b0(%rip), %rdi      # 0xd580
movb $0x0, %al
callq 0x5970
movl $0x0, -0x4(%rbp)
jmp 0x9c29
jmp 0x9be2
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x9c0f
leaq 0x7cb7(%rip), %rdi      # 0x118b0
movl $0x2, %esi
callq 0x99b0
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jne 0x9c0d
jmp 0x9c0f
jmp 0x9be2
cmpl $0x0, -0x10(%rbp)
jne 0x9c23
leaq 0x395a(%rip), %rdi      # 0xd576
movb $0x0, %al
callq 0x5970
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x9c5b
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x9c73
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0x9b80
movl %eax, -0x4(%rbp)
jmp 0x9ca7
leaq 0x7c36(%rip), %rax      # 0x118b0
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9c99
leaq 0x38f7(%rip), %rdi      # 0xd580
movb $0x0, %al
callq 0x5970
movl $0x0, -0x4(%rbp)
jmp 0x9ca7
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x9cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ThomasMadappattu[P]Sandmacs/search.c
// Function: eq
int eq (int bc, int pc)
{
  if (bc >= 'a' && bc <= 'z')
    bc -= 0x20;
  if (pc >= 'a' && pc <= 'z')
    pc -= 0x20;
  if (bc == pc)
    return (TRUE);
  return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x61, -0x8(%rbp)
jl 0x9edf
cmpl $0x7a, -0x8(%rbp)
jg 0x9edf
movl -0x8(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x8(%rbp)
cmpl $0x61, -0xc(%rbp)
jl 0x9ef4
cmpl $0x7a, -0xc(%rbp)
jg 0x9ef4
movl -0xc(%rbp), %eax
subl $0x20, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x9f05
movl $0x1, -0x4(%rbp)
jmp 0x9f0c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ThomasMadappattu[P]Sandmacs/search.c
// Function: expandp
void expandp (char *srcstr, char *deststr, int maxlength)
{
  char c;			/* current char to translate */

  /* scan through the string */
  while ((c = *srcstr++) != 0)
    {
      if (c == '\n')
	{			/* its an EOL */
	  *deststr++ = '<';
	  *deststr++ = 'N';
	  *deststr++ = 'L';
	  *deststr++ = '>';
	  maxlength -= 4;
	}
      else if (c < 0x20 || c == 0x7f)
	{			/* control character */
	  *deststr++ = '^';
	  *deststr++ = c ^ 0x40;
	  maxlength -= 2;
	}
      else if (c == '%')
	{
	  *deststr++ = '%';
	  *deststr++ = '%';
	  maxlength -= 2;
	}
      else
	{			/* any other character */
	  *deststr++ = c;
	  maxlength--;
	}

      /* check for maxlength */
      if (maxlength < 4)
	{
	  *deststr++ = '$';
	  *deststr = '\0';
	  return;
	}
    }
  *deststr = '\0';
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x15(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa076
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
jne 0x9fae
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x3c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x4e, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x4c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x3e, (%rax)
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0xa050
movsbl -0x15(%rbp), %eax
cmpl $0x20, %eax
jl 0x9fc0
movsbl -0x15(%rbp), %eax
cmpl $0x7f, %eax
jne 0x9ff7
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5e, (%rax)
movsbl -0x15(%rbp), %eax
xorl $0x40, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xa04e
movsbl -0x15(%rbp), %eax
cmpl $0x25, %eax
jne 0xa02f
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x25, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x25, (%rax)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xa04c
movb -0x15(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa04e
jmp 0xa050
cmpl $0x4, -0x14(%rbp)
jge 0xa071
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x24, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0xa07d
jmp 0x9f2f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb759
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0xb7f0
movl %eax, -0x4(%rbp)
jmp 0xb7e6
xorl %edi, %edi
movl $0x1, %esi
callq 0x2400
cmpl $0x0, %eax
jne 0xb773
movl $0x0, -0x4(%rbp)
jmp 0xb7e6
jmp 0xb775
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xb7d7
jmp 0xb787
callq 0xbe70
cmpl $0x0, %eax
jne 0xb7ad
xorl %edi, %edi
movl $0x1, %esi
callq 0x2400
cmpl $0x0, %eax
jne 0xb7ab
movl $0x0, -0x4(%rbp)
jmp 0xb7e6
jmp 0xb787
jmp 0xb7af
callq 0xbe70
cmpl $0x0, %eax
je 0xb7d5
xorl %edi, %edi
movl $0x1, %esi
callq 0x2400
cmpl $0x0, %eax
jne 0xb7d3
movl $0x0, -0x4(%rbp)
jmp 0xb7e6
jmp 0xb7af
jmp 0xb775
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb816
movl -0x8(%rbp), %edi
xorl %esi, %esi
subl -0xc(%rbp), %esi
callq 0xb730
movl %eax, -0x4(%rbp)
jmp 0xb881
jmp 0xb818
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xb87a
jmp 0xb82a
callq 0xbe70
cmpl $0x0, %eax
je 0xb850
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xb84e
movl $0x0, -0x4(%rbp)
jmp 0xb881
jmp 0xb82a
jmp 0xb852
callq 0xbe70
cmpl $0x0, %eax
jne 0xb878
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xb876
movl $0x0, -0x4(%rbp)
jmp 0xb881
jmp 0xb852
jmp 0xb818
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb8b0
movl $0x0, -0x4(%rbp)
jmp 0xb999
jmp 0xb8b2
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xb992
jmp 0xb8c8
callq 0xbe70
cmpl $0x0, %eax
jne 0xb8f1
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xb8ef
movl $0x0, -0x4(%rbp)
jmp 0xb999
jmp 0xb8c8
jmp 0xb8f3
callq 0xbe70
cmpl $0x0, %eax
je 0xb98d
leaq 0x5f70(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0x5f62(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
cmpl $0x61, -0x10(%rbp)
jl 0xb96e
cmpl $0x7a, -0x10(%rbp)
jg 0xb96e
movl -0x10(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, %dl
leaq 0x5f2d(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0x5f1f(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movb %dl, 0x18(%rax,%rcx)
movl $0x8, %edi
callq 0x70b0
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xb988
movl $0x0, -0x4(%rbp)
jmp 0xb999
jmp 0xb8f3
jmp 0xb8b2
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/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xb9d0
movl $0x0, -0x4(%rbp)
jmp 0xbab9
jmp 0xb9d2
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xbab2
jmp 0xb9e8
callq 0xbe70
cmpl $0x0, %eax
jne 0xba11
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xba0f
movl $0x0, -0x4(%rbp)
jmp 0xbab9
jmp 0xb9e8
jmp 0xba13
callq 0xbe70
cmpl $0x0, %eax
je 0xbaad
leaq 0x5e50(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0x5e42(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movsbl 0x18(%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
cmpl $0x41, -0x10(%rbp)
jl 0xba8e
cmpl $0x5a, -0x10(%rbp)
jg 0xba8e
movl -0x10(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, %dl
leaq 0x5e0d(%rip), %rax      # 0x11878
movq (%rax), %rax
movq 0x18(%rax), %rax
leaq 0x5dff(%rip), %rcx      # 0x11878
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
movb %dl, 0x18(%rax,%rcx)
movl $0x8, %edi
callq 0x70b0
xorl %edi, %edi
movl $0x1, %esi
callq 0x24f0
cmpl $0x0, %eax
jne 0xbaa8
movl $0x0, -0x4(%rbp)
jmp 0xbab9
jmp 0xba13
jmp 0xb9d2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)