#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ ffpmsg(char *);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
size_t strcspn(char *, char *);
size_t strlen(char *);
int strncmp(char *, char *, int);
int /*<<< orphan*/ strncpy(char *, char *, size_t);
size_t strspn(char *, char *);
int ffpsvc(char *card, char *value, char *comm, int *status) {
  int jj;
  size_t ii, cardlen, nblank, valpos;
  if (*status > 0)
    return (*status);
  value[0] = '\0';
  if (comm)
    comm[0] = '\0';
  cardlen = strlen(card);
  if (((card)[0] < ("HIERARCH ")[0] ? -1
       : (card)[0] > ("HIERARCH ")[0]
           ? 1
           : strncmp((card), ("HIERARCH "), (9))) == 0) {
    valpos = strcspn(card, "=");
    if (valpos == cardlen) {
      if (comm != NULL) {
        if (cardlen > 8) {
          strcpy(comm, &card[8]);
          jj = cardlen - 8;
          for (jj--; jj >= 0; jj--) {
            if (comm[jj] == ' ')
              comm[jj] = '\0';
            else
              break;
          }
        }
      }
      return (*status);
    }
    valpos++;
  } else if (cardlen < 9 ||
             ((card)[0] < ("COMMENT ")[0] ? -1
              : (card)[0] > ("COMMENT ")[0]
                  ? 1
                  : strncmp((card), ("COMMENT "), (8))) == 0 ||
             ((card)[0] < ("HISTORY ")[0] ? -1
              : (card)[0] > ("HISTORY ")[0]
                  ? 1
                  : strncmp((card), ("HISTORY "), (8))) == 0 ||
             ((card)[0] < ("END     ")[0] ? -1
              : (card)[0] > ("END     ")[0]
                  ? 1
                  : strncmp((card), ("END     "), (8))) == 0 ||
             ((card)[0] < ("CONTINUE")[0] ? -1
              : (card)[0] > ("CONTINUE")[0]
                  ? 1
                  : strncmp((card), ("CONTINUE"), (8))) == 0 ||
             ((card)[0] < ("        ")[0] ? -1
              : (card)[0] > ("        ")[0]
                  ? 1
                  : strncmp((card), ("        "), (8))) == 0) {
    if (comm != NULL) {
      if (cardlen > 8) {
        strcpy(comm, &card[8]);
        jj = cardlen - 8;
        for (jj--; jj >= 0; jj--) {
          if (comm[jj] == ' ')
            comm[jj] = '\0';
          else
            break;
        }
      }
    }
    return (*status);
  } else if (((&card[8])[0] < ("= ")[0] ? -1
              : (&card[8])[0] > ("= ")[0]
                  ? 1
                  : strncmp((&card[8]), ("= "), (2))) == 0) {
    valpos = 10;
  } else {
    valpos = strcspn(card, "=");
    if (valpos == cardlen) {
      if (comm != NULL) {
        if (cardlen > 8) {
          strcpy(comm, &card[8]);
          jj = cardlen - 8;
          for (jj--; jj >= 0; jj--) {
            if (comm[jj] == ' ')
              comm[jj] = '\0';
            else
              break;
          }
        }
      }
      return (*status);
    }
    valpos++;
  }
  nblank = strspn(&card[valpos], " ");
  if (nblank + valpos == cardlen) {
    return (*status);
  }
  ii = valpos + nblank;
  if (card[ii] == '/') {
    ii++;
  } else if (card[ii] == '\'') {
    value[0] = card[ii];
    for (jj = 1, ii++; ii < cardlen; ii++, jj++) {
      if (card[ii] == '\'') {
        if (card[ii + 1] == '\'') {
          value[jj] = card[ii];
          ii++;
          jj++;
        } else {
          value[jj] = card[ii];
          break;
        }
      }
      value[jj] = card[ii];
    }
    if (ii == cardlen) {
      jj = ((jj) < (69) ? (jj) : (69));
      value[jj] = '\'';
      value[jj + 1] = '\0';
      ffpmsg("This keyword string value has no closing quote:");
      ffpmsg(card);
    } else {
      value[jj + 1] = '\0';
      ii++;
    }
  } else if (card[ii] == '(') {
    nblank = strcspn(&card[ii], ")");
    if (nblank == strlen(&card[ii])) {
      ffpmsg("This complex keyword value has no closing ')':");
      ffpmsg(card);
      return (*status = 205);
    }
    nblank++;
    strncpy(value, &card[ii], nblank);
    value[nblank] = '\0';
    ii = ii + nblank;
  } else {
    nblank = strcspn(&card[ii], " /");
    strncpy(value, &card[ii], nblank);
    value[nblank] = '\0';
    ii = ii + nblank;
  }
  if (comm) {
    nblank = strspn(&card[ii], " ");
    ii = ii + nblank;
    if (ii < 80) {
      if (card[ii] == '/') {
        ii++;
        if (card[ii] == ' ')
          ii++;
      }
      strcat(comm, &card[ii]);
      jj = strlen(comm);
      for (jj--; jj >= 0; jj--) {
        if (comm[jj] == ' ')
          comm[jj] = '\0';
        else
          break;
      }
    }
  }
  return (*status);
}


x86 assembly (clang, -O0):
<ffpsvc>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jle    11b6 <ffpsvc+0x36>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
cmpq   $0x0,-0x20(%rbp)
je     11cf <ffpsvc+0x4f>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rdi
call   1060 <strlen@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xe16(%rip),%ecx
cmp    %ecx,%eax
jge    11ff <ffpsvc+0x7f>
mov    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1240 <ffpsvc+0xc0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xdf3(%rip),%ecx
cmp    %ecx,%eax
jle    1222 <ffpsvc+0xa2>
mov    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    123a <ffpsvc+0xba>
mov    -0x10(%rbp),%rdi
lea    0xdd3(%rip),%rsi
mov    $0x9,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    $0x0,%eax
jne    131a <ffpsvc+0x19a>
mov    -0x10(%rbp),%rdi
lea    0xdb3(%rip),%rsi
call   1090 <strcspn@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    1309 <ffpsvc+0x189>
cmpq   $0x0,-0x20(%rbp)
je     12fb <ffpsvc+0x17b>
cmpq   $0x8,-0x40(%rbp)
jbe    12f6 <ffpsvc+0x176>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
call   1050 <strcpy@plt>
mov    -0x40(%rbp),%rax
sub    $0x8,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     12f1 <ffpsvc+0x171>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    12d9 <ffpsvc+0x159>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    12de <ffpsvc+0x15e>
jmp    12f1 <ffpsvc+0x171>
jmp    12e3 <ffpsvc+0x163>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12a9 <ffpsvc+0x129>
jmp    12f6 <ffpsvc+0x176>
jmp    12fb <ffpsvc+0x17b>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1758 <ffpsvc+0x5d8>
cmpq   $0x9,-0x40(%rbp)
jb     1555 <ffpsvc+0x3d5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xcd9(%rip),%ecx
cmp    %ecx,%eax
jge    1348 <ffpsvc+0x1c8>
mov    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1389 <ffpsvc+0x209>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xcb6(%rip),%ecx
cmp    %ecx,%eax
jle    136b <ffpsvc+0x1eb>
mov    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1383 <ffpsvc+0x203>
mov    -0x10(%rbp),%rdi
lea    0xc96(%rip),%rsi
mov    $0x8,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    $0x0,%eax
je     1555 <ffpsvc+0x3d5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc72(%rip),%ecx
cmp    %ecx,%eax
jge    13b8 <ffpsvc+0x238>
mov    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    13f9 <ffpsvc+0x279>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc4f(%rip),%ecx
cmp    %ecx,%eax
jle    13db <ffpsvc+0x25b>
mov    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13f3 <ffpsvc+0x273>
mov    -0x10(%rbp),%rdi
lea    0xc2f(%rip),%rsi
mov    $0x8,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    $0x0,%eax
je     1555 <ffpsvc+0x3d5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xc0b(%rip),%ecx
cmp    %ecx,%eax
jge    1428 <ffpsvc+0x2a8>
mov    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
jmp    1469 <ffpsvc+0x2e9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xbe8(%rip),%ecx
cmp    %ecx,%eax
jle    144b <ffpsvc+0x2cb>
mov    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1463 <ffpsvc+0x2e3>
mov    -0x10(%rbp),%rdi
lea    0xbc8(%rip),%rsi
mov    $0x8,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    $0x0,%eax
je     1555 <ffpsvc+0x3d5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xba4(%rip),%ecx
cmp    %ecx,%eax
jge    1498 <ffpsvc+0x318>
mov    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    14d9 <ffpsvc+0x359>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xb81(%rip),%ecx
cmp    %ecx,%eax
jle    14bb <ffpsvc+0x33b>
mov    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14d3 <ffpsvc+0x353>
mov    -0x10(%rbp),%rdi
lea    0xb61(%rip),%rsi
mov    $0x8,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    $0x0,%eax
je     1555 <ffpsvc+0x3d5>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xb3d(%rip),%ecx
cmp    %ecx,%eax
jge    1508 <ffpsvc+0x388>
mov    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
jmp    1549 <ffpsvc+0x3c9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl 0xb1a(%rip),%ecx
cmp    %ecx,%eax
jle    152b <ffpsvc+0x3ab>
mov    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1543 <ffpsvc+0x3c3>
mov    -0x10(%rbp),%rdi
lea    0xafa(%rip),%rsi
mov    $0x8,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    $0x0,%eax
jne    15f0 <ffpsvc+0x470>
cmpq   $0x0,-0x20(%rbp)
je     15e2 <ffpsvc+0x462>
cmpq   $0x8,-0x40(%rbp)
jbe    15dd <ffpsvc+0x45d>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
call   1050 <strcpy@plt>
mov    -0x40(%rbp),%rax
sub    $0x8,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     15d8 <ffpsvc+0x458>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    15c0 <ffpsvc+0x440>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    15c5 <ffpsvc+0x445>
jmp    15d8 <ffpsvc+0x458>
jmp    15ca <ffpsvc+0x44a>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1590 <ffpsvc+0x410>
jmp    15dd <ffpsvc+0x45d>
jmp    15e2 <ffpsvc+0x462>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x10(%rbp),%rax
movsbl 0x8(%rax),%eax
movsbl 0xa3a(%rip),%ecx
cmp    %ecx,%eax
jge    1617 <ffpsvc+0x497>
mov    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    1669 <ffpsvc+0x4e9>
mov    -0x10(%rbp),%rax
movsbl 0x8(%rax),%eax
movsbl 0xa13(%rip),%ecx
cmp    %ecx,%eax
jle    163e <ffpsvc+0x4be>
mov    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    165d <ffpsvc+0x4dd>
mov    -0x10(%rbp),%rdi
add    $0x8,%rdi
lea    0x9ec(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    $0x0,%eax
jne    1685 <ffpsvc+0x505>
movq   $0xa,-0x50(%rbp)
jmp    174e <ffpsvc+0x5ce>
mov    -0x10(%rbp),%rdi
lea    0x97a(%rip),%rsi
call   1090 <strcspn@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    1742 <ffpsvc+0x5c2>
cmpq   $0x0,-0x20(%rbp)
je     1734 <ffpsvc+0x5b4>
cmpq   $0x8,-0x40(%rbp)
jbe    172f <ffpsvc+0x5af>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
call   1050 <strcpy@plt>
mov    -0x40(%rbp),%rax
sub    $0x8,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     172a <ffpsvc+0x5aa>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1712 <ffpsvc+0x592>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1717 <ffpsvc+0x597>
jmp    172a <ffpsvc+0x5aa>
jmp    171c <ffpsvc+0x59c>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    16e2 <ffpsvc+0x562>
jmp    172f <ffpsvc+0x5af>
jmp    1734 <ffpsvc+0x5b4>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1753 <ffpsvc+0x5d3>
jmp    1758 <ffpsvc+0x5d8>
mov    -0x10(%rbp),%rdi
add    -0x50(%rbp),%rdi
lea    0x8d0(%rip),%rsi
call   1080 <strspn@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    1790 <ffpsvc+0x610>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x50(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    17c2 <ffpsvc+0x642>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1a5c <ffpsvc+0x8dc>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x27,%eax
jne    194c <ffpsvc+0x7cc>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    18b4 <ffpsvc+0x734>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x27,%eax
jne    1884 <ffpsvc+0x704>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
cmp    $0x27,%eax
jne    1864 <ffpsvc+0x6e4>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    187f <ffpsvc+0x6ff>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    18b4 <ffpsvc+0x734>
jmp    1884 <ffpsvc+0x704>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17fb <ffpsvc+0x67b>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    192a <ffpsvc+0x7aa>
cmpl   $0x45,-0x2c(%rbp)
jge    18da <ffpsvc+0x75a>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    18ea <ffpsvc+0x76a>
mov    $0x45,%eax
mov    %eax,-0x8c(%rbp)
jmp    18ea <ffpsvc+0x76a>
mov    -0x8c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x27,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
lea    0x725(%rip),%rdi
call   1070 <ffpmsg@plt>
mov    -0x10(%rbp),%rdi
call   1070 <ffpmsg@plt>
jmp    1947 <ffpsvc+0x7c7>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1a57 <ffpsvc+0x8d7>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1a0d <ffpsvc+0x88d>
mov    -0x10(%rbp),%rdi
add    -0x38(%rbp),%rdi
lea    0x6fc(%rip),%rsi
call   1090 <strcspn@plt>
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rdi
add    -0x38(%rbp),%rdi
call   1060 <strlen@plt>
mov    %rax,%rcx
mov    -0x98(%rbp),%rax
cmp    %rcx,%rax
jne    19cf <ffpsvc+0x84f>
lea    0x6c3(%rip),%rdi
call   1070 <ffpmsg@plt>
mov    -0x10(%rbp),%rdi
call   1070 <ffpmsg@plt>
mov    -0x28(%rbp),%rax
movl   $0xcd,(%rax)
movl   $0xcd,-0x4(%rbp)
jmp    1b5e <ffpsvc+0x9de>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rdx
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1a52 <ffpsvc+0x8d2>
mov    -0x10(%rbp),%rdi
add    -0x38(%rbp),%rdi
lea    0x681(%rip),%rsi
call   1090 <strcspn@plt>
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rdx
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1a57 <ffpsvc+0x8d7>
jmp    1a5c <ffpsvc+0x8dc>
cmpq   $0x0,-0x20(%rbp)
je     1b55 <ffpsvc+0x9d5>
mov    -0x10(%rbp),%rdi
add    -0x38(%rbp),%rdi
lea    0x5c1(%rip),%rsi
call   1080 <strspn@plt>
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x50,-0x38(%rbp)
jae    1b50 <ffpsvc+0x9d0>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    1add <ffpsvc+0x95d>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1ad8 <ffpsvc+0x958>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1add <ffpsvc+0x95d>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    -0x38(%rbp),%rsi
call   10a0 <strcat@plt>
mov    -0x20(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1b4b <ffpsvc+0x9cb>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1b33 <ffpsvc+0x9b3>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1b38 <ffpsvc+0x9b8>
jmp    1b4b <ffpsvc+0x9cb>
jmp    1b3d <ffpsvc+0x9bd>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b03 <ffpsvc+0x983>
jmp    1b50 <ffpsvc+0x9d0>
jmp    1b55 <ffpsvc+0x9d5>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ffpsvc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    (%rcx),%eax
test   %eax,%eax
jg     11e0 <ffpsvc+0x60>
mov    %rcx,%rbp
mov    %rdx,%r15
mov    %rsi,%r13
mov    %rdi,%r12
movb   $0x0,(%rsi)
test   %rdx,%rdx
je     11a9 <ffpsvc+0x29>
movb   $0x0,(%r15)
mov    %r12,%rdi
call   1060 <strlen@plt>
mov    %rax,%rbx
cmpb   $0x48,(%r12)
jne    11d7 <ffpsvc+0x57>
lea    0xe3e(%rip),%rsi
mov    %r12,%rdi
mov    $0x9,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     136e <ffpsvc+0x1ee>
cmp    $0x9,%rbx
jae    11ef <ffpsvc+0x6f>
mov    0x0(%rbp),%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%r12),%al
cmp    $0x43,%al
jne    1217 <ffpsvc+0x97>
lea    0xe0e(%rip),%rsi
mov    %r12,%rdi
mov    $0x8,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1323 <ffpsvc+0x1a3>
mov    (%r12),%al
cmp    $0x48,%al
jne    123b <ffpsvc+0xbb>
lea    0xdf3(%rip),%rsi
mov    %r12,%rdi
mov    $0x8,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1323 <ffpsvc+0x1a3>
mov    (%r12),%al
cmp    $0x45,%al
jne    125f <ffpsvc+0xdf>
lea    0xdd8(%rip),%rsi
mov    %r12,%rdi
mov    $0x8,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1323 <ffpsvc+0x1a3>
mov    (%r12),%al
cmp    $0x43,%al
jne    1283 <ffpsvc+0x103>
lea    0xdbd(%rip),%rsi
mov    %r12,%rdi
mov    $0x8,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1323 <ffpsvc+0x1a3>
mov    (%r12),%al
cmp    $0x20,%al
jne    12a3 <ffpsvc+0x123>
lea    0xda2(%rip),%rsi
mov    %r12,%rdi
mov    $0x8,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1323 <ffpsvc+0x1a3>
mov    %rbp,(%rsp)
lea    0x8(%r12),%rbp
cmpb   $0x3d,0x8(%r12)
jne    12d0 <ffpsvc+0x150>
lea    0xd7e(%rip),%rsi
mov    %rbp,%rdi
mov    $0x2,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1422 <ffpsvc+0x2a2>
lea    0xd33(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcspn@plt>
cmp    %rbx,%rax
jne    13d4 <ffpsvc+0x254>
test   %r15,%r15
je     13f6 <ffpsvc+0x276>
mov    %r15,%rdi
mov    %rbp,%rsi
call   1050 <strcpy@plt>
add    $0xfffffff7,%ebx
js     13f6 <ffpsvc+0x276>
mov    %ebx,%eax
cmpb   $0x20,(%r15,%rax,1)
jne    13f6 <ffpsvc+0x276>
movb   $0x0,(%r15,%rax,1)
lea    -0x1(%rax),%ebx
test   %eax,%eax
jg     1305 <ffpsvc+0x185>
jmp    13f6 <ffpsvc+0x276>
test   %r15,%r15
je     11dd <ffpsvc+0x5d>
add    $0x8,%r12
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <strcpy@plt>
add    $0xfffffff7,%ebx
js     11dd <ffpsvc+0x5d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%eax
cmpb   $0x20,(%r15,%rax,1)
jne    11dd <ffpsvc+0x5d>
movb   $0x0,(%r15,%rax,1)
lea    -0x1(%rax),%ebx
test   %eax,%eax
jg     1350 <ffpsvc+0x1d0>
jmp    11dd <ffpsvc+0x5d>
lea    0xc95(%rip),%rsi
mov    %r12,%rdi
call   1090 <strcspn@plt>
cmp    %rbx,%rax
jne    13cb <ffpsvc+0x24b>
test   %r15,%r15
je     11dd <ffpsvc+0x5d>
cmp    $0x9,%rbx
jb     11dd <ffpsvc+0x5d>
add    $0x8,%r12
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <strcpy@plt>
add    $0xfffffff7,%ebx
js     11dd <ffpsvc+0x5d>
mov    %ebx,%eax
cmpb   $0x20,(%r15,%rax,1)
jne    11dd <ffpsvc+0x5d>
movb   $0x0,(%r15,%rax,1)
lea    -0x1(%rax),%ebx
test   %eax,%eax
jg     13ad <ffpsvc+0x22d>
jmp    11dd <ffpsvc+0x5d>
mov    %rax,%r14
mov    %rbp,(%rsp)
jmp    13d7 <ffpsvc+0x257>
mov    %rax,%r14
add    $0x1,%r14
lea    (%r12,%r14,1),%rdi
lea    0xc51(%rip),%rsi
call   1080 <strspn@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmp    %rbx,%rbp
jne    1401 <ffpsvc+0x281>
mov    (%rsp),%rax
mov    (%rax),%eax
jmp    11e0 <ffpsvc+0x60>
mov    (%r12,%rbp,1),%al
cmp    $0x27,%al
je     1475 <ffpsvc+0x2f5>
lea    (%r12,%rbp,1),%r14
cmp    $0x28,%al
je     142a <ffpsvc+0x2aa>
cmp    $0x2f,%al
jne    14ce <ffpsvc+0x34e>
add    $0x1,%rbp
jmp    1554 <ffpsvc+0x3d4>
mov    $0xa,%r14d
jmp    13db <ffpsvc+0x25b>
lea    0xc3b(%rip),%rsi
mov    %r14,%rdi
call   1090 <strcspn@plt>
mov    %rax,%rbx
mov    %r14,%rdi
call   1060 <strlen@plt>
cmp    %rax,%rbx
jne    152a <ffpsvc+0x3aa>
lea    0xc1a(%rip),%rdi
call   1070 <ffpmsg@plt>
mov    %r12,%rdi
call   1070 <ffpmsg@plt>
mov    (%rsp),%rax
movl   $0xcd,(%rax)
mov    $0xcd,%eax
jmp    11e0 <ffpsvc+0x60>
movb   $0x27,0x0(%r13)
lea    0x1(%rbp),%rcx
mov    $0x1,%eax
cmp    %rbx,%rcx
jae    14f9 <ffpsvc+0x379>
mov    $0x1,%eax
jmp    14a5 <ffpsvc+0x325>
mov    %rcx,%rbp
cltq
mov    %dl,0x0(%r13,%rax,1)
add    $0x1,%eax
lea    0x1(%rbp),%rcx
cmp    %rbx,%rcx
jae    14f9 <ffpsvc+0x379>
movzbl (%r12,%rcx,1),%edx
cmp    $0x27,%dl
jne    148f <ffpsvc+0x30f>
cmpb   $0x27,0x2(%r12,%rbp,1)
movslq %eax,%rdx
movb   $0x27,0x0(%r13,%rdx,1)
jne    14f9 <ffpsvc+0x379>
add    $0x2,%rbp
add    $0x1,%eax
movzbl (%r12,%rbp,1),%edx
jmp    1492 <ffpsvc+0x312>
lea    0xbc8(%rip),%rsi
mov    %r14,%rdi
call   1090 <strcspn@plt>
mov    %rax,%rbx
mov    %r13,%rdi
mov    %r14,%rsi
mov    %rax,%rdx
call   1030 <strncpy@plt>
movb   $0x0,0x0(%r13,%rbx,1)
add    %rbx,%rbp
jmp    1554 <ffpsvc+0x3d4>
cmp    %rbx,%rcx
jne    1548 <ffpsvc+0x3c8>
cmp    $0x45,%eax
mov    $0x45,%ecx
cmovl  %eax,%ecx
movslq %ecx,%rax
movw   $0x27,0x0(%r13,%rax,1)
lea    0xb21(%rip),%rdi
call   1070 <ffpmsg@plt>
mov    %r12,%rdi
call   1070 <ffpmsg@plt>
jmp    1557 <ffpsvc+0x3d7>
lea    0x1(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   1030 <strncpy@plt>
movb   $0x0,0x1(%r13,%rbx,1)
add    %rbp,%rbx
add    $0x1,%rbx
jmp    1557 <ffpsvc+0x3d7>
cltq
movb   $0x0,0x1(%rax,%r13,1)
add    $0x2,%rbp
mov    %rbp,%rbx
mov    (%rsp),%rbp
test   %r15,%r15
je     11dd <ffpsvc+0x5d>
lea    (%r12,%rbx,1),%rdi
lea    0xac8(%rip),%rsi
call   1080 <strspn@plt>
add    %rbx,%rax
cmp    $0x4f,%rax
ja     11dd <ffpsvc+0x5d>
cmpb   $0x2f,(%r12,%rax,1)
jne    159a <ffpsvc+0x41a>
cmpb   $0x20,0x1(%r12,%rax,1)
lea    0x2(%rax),%rcx
lea    0x1(%rax),%rax
cmove  %rcx,%rax
add    %rax,%r12
mov    %r15,%rdi
mov    %r12,%rsi
call   10a0 <strcat@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    11dd <ffpsvc+0x5d>
mov    %eax,%eax
add    $0x1,%rax
lea    -0x2(%rax),%ecx
cmpb   $0x20,(%r15,%rcx,1)
jne    11dd <ffpsvc+0x5d>
movb   $0x0,(%r15,%rcx,1)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     15be <ffpsvc+0x43e>
jmp    11dd <ffpsvc+0x5d>

LLVM IR (-O0):
@.str = [10 x i8] c"HIERARCH \00"
@.str.1 = [2 x i8] c"=\00"
@.str.2 = [9 x i8] c"COMMENT \00"
@.str.3 = [9 x i8] c"HISTORY \00"
@.str.4 = [9 x i8] c"END \00"
@.str.5 = [9 x i8] c"CONTINUE\00"
@.str.6 = [9 x i8] c" \00"
@.str.7 = [3 x i8] c"= \00"
@.str.8 = [2 x i8] c" \00"
@.str.9 = [48 x i8] c"This keyword string value has no closing quote:\00"
@.str.10 = [2 x i8] c")\00"
@.str.11 = [47 x i8] c"This complex keyword value has no closing ')':\00"
@.str.12 = [3 x i8] c" /\00"
define i32 @ffpsvc(i8* %0, i8* %1, i8* %2, i32* %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i32* %3, i32** %9
%15 = load i32*, i32** %9
%16 = load i32, i32* %15
%17 = icmp sgt i32 %16, 0
br i1 %17, label %18, label %21
18: ; preds = %4
%19 = load i32*, i32** %9
%20 = load i32, i32* %19
store i32 %20, i32* %5
br label %624
21: ; preds = %4
%22 = load i8*, i8** %7
%23 = getelementptr inbounds i8, i8* %22, i64 0
store i8 0, i8* %23
%24 = load i8*, i8** %8
%25 = icmp ne i8* %24, null
br i1 %25, label %26, label %29
26: ; preds = %21
%27 = load i8*, i8** %8
%28 = getelementptr inbounds i8, i8* %27, i64 0
store i8 0, i8* %28
br label %29
29: ; preds = %26, %21
%30 = load i8*, i8** %6
%31 = call i64 @strlen(i8* %30)
store i64 %31, i64* %12
%32 = load i8*, i8** %6
%33 = getelementptr inbounds i8, i8* %32, i64 0
%34 = load i8, i8* %33
%35 = sext i8 %34 to i32
%36 = load i8, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0)
%37 = sext i8 %36 to i32
%38 = icmp slt i32 %35, %37
br i1 %38, label %39, label %40
39: ; preds = %29
br label %54
40: ; preds = %29
%41 = load i8*, i8** %6
%42 = getelementptr inbounds i8, i8* %41, i64 0
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = load i8, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0)
%46 = sext i8 %45 to i32
%47 = icmp sgt i32 %44, %46
br i1 %47, label %48, label %49
48: ; preds = %40
br label %52
49: ; preds = %40
%50 = load i8*, i8** %6
%51 = call i32 @strncmp(i8* %50, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i32 9)
br label %52
52: ; preds = %49, %48
%53 = phi i32 [ 1, %48 ], [ %51, %49 ]
br label %54
54: ; preds = %52, %39
%55 = phi i32 [ -1, %39 ], [ %53, %52 ]
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %108
57: ; preds = %54
%58 = load i8*, i8** %6
%59 = call i64 @strcspn(i8* %58, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i64 %59, i64* %14
%60 = load i64, i64* %14
%61 = load i64, i64* %12
%62 = icmp eq i64 %60, %61
br i1 %62, label %63, label %105
63: ; preds = %57
%64 = load i8*, i8** %8
%65 = icmp ne i8* %64, null
br i1 %65, label %66, label %102
66: ; preds = %63
%67 = load i64, i64* %12
%68 = icmp ugt i64 %67, 8
br i1 %68, label %69, label %101
69: ; preds = %66
%70 = load i8*, i8** %8
%71 = load i8*, i8** %6
%72 = getelementptr inbounds i8, i8* %71, i64 8
%73 = call i32 @strcpy(i8* %70, i8* %72)
%74 = load i64, i64* %12
%75 = sub i64 %74, 8
%76 = trunc i64 %75 to i32
store i32 %76, i32* %10
%77 = load i32, i32* %10
%78 = add nsw i32 %77, -1
store i32 %78, i32* %10
br label %79
79: ; preds = %97, %69
%80 = load i32, i32* %10
%81 = icmp sge i32 %80, 0
br i1 %81, label %82, label %100
82: ; preds = %79
%83 = load i8*, i8** %8
%84 = load i32, i32* %10
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp eq i32 %88, 32
br i1 %89, label %90, label %95
90: ; preds = %82
%91 = load i8*, i8** %8
%92 = load i32, i32* %10
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
store i8 0, i8* %94
br label %96
95: ; preds = %82
br label %100
96: ; preds = %90
br label %97
97: ; preds = %96
%98 = load i32, i32* %10
%99 = add nsw i32 %98, -1
store i32 %99, i32* %10
br label %79
100: ; preds = %95, %79
br label %101
101: ; preds = %100, %66
br label %102
102: ; preds = %101, %63
%103 = load i32*, i32** %9
%104 = load i32, i32* %103
store i32 %104, i32* %5
br label %624
105: ; preds = %57
%106 = load i64, i64* %14
%107 = add i64 %106, 1
store i64 %107, i64* %14
br label %366
108: ; preds = %54
%109 = load i64, i64* %12
%110 = icmp ult i64 %109, 9
br i1 %110, label %241, label %111
111: ; preds = %108
%112 = load i8*, i8** %6
%113 = getelementptr inbounds i8, i8* %112, i64 0
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0)
%117 = sext i8 %116 to i32
%118 = icmp slt i32 %115, %117
br i1 %118, label %119, label %120
119: ; preds = %111
br label %134
120: ; preds = %111
%121 = load i8*, i8** %6
%122 = getelementptr inbounds i8, i8* %121, i64 0
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0)
%126 = sext i8 %125 to i32
%127 = icmp sgt i32 %124, %126
br i1 %127, label %128, label %129
128: ; preds = %120
br label %132
129: ; preds = %120
%130 = load i8*, i8** %6
%131 = call i32 @strncmp(i8* %130, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i32 8)
br label %132
132: ; preds = %129, %128
%133 = phi i32 [ 1, %128 ], [ %131, %129 ]
br label %134
134: ; preds = %132, %119
%135 = phi i32 [ -1, %119 ], [ %133, %132 ]
%136 = icmp eq i32 %135, 0
br i1 %136, label %241, label %137
137: ; preds = %134
%138 = load i8*, i8** %6
%139 = getelementptr inbounds i8, i8* %138, i64 0
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0)
%143 = sext i8 %142 to i32
%144 = icmp slt i32 %141, %143
br i1 %144, label %145, label %146
145: ; preds = %137
br label %160
146: ; preds = %137
%147 = load i8*, i8** %6
%148 = getelementptr inbounds i8, i8* %147, i64 0
%149 = load i8, i8* %148
%150 = sext i8 %149 to i32
%151 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0)
%152 = sext i8 %151 to i32
%153 = icmp sgt i32 %150, %152
br i1 %153, label %154, label %155
154: ; preds = %146
br label %158
155: ; preds = %146
%156 = load i8*, i8** %6
%157 = call i32 @strncmp(i8* %156, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0), i32 8)
br label %158
158: ; preds = %155, %154
%159 = phi i32 [ 1, %154 ], [ %157, %155 ]
br label %160
160: ; preds = %158, %145
%161 = phi i32 [ -1, %145 ], [ %159, %158 ]
%162 = icmp eq i32 %161, 0
br i1 %162, label %241, label %163
163: ; preds = %160
%164 = load i8*, i8** %6
%165 = getelementptr inbounds i8, i8* %164, i64 0
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0)
%169 = sext i8 %168 to i32
%170 = icmp slt i32 %167, %169
br i1 %170, label %171, label %172
171: ; preds = %163
br label %186
172: ; preds = %163
%173 = load i8*, i8** %6
%174 = getelementptr inbounds i8, i8* %173, i64 0
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0)
%178 = sext i8 %177 to i32
%179 = icmp sgt i32 %176, %178
br i1 %179, label %180, label %181
180: ; preds = %172
br label %184
181: ; preds = %172
%182 = load i8*, i8** %6
%183 = call i32 @strncmp(i8* %182, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i32 8)
br label %184
184: ; preds = %181, %180
%185 = phi i32 [ 1, %180 ], [ %183, %181 ]
br label %186
186: ; preds = %184, %171
%187 = phi i32 [ -1, %171 ], [ %185, %184 ]
%188 = icmp eq i32 %187, 0
br i1 %188, label %241, label %189
189: ; preds = %186
%190 = load i8*, i8** %6
%191 = getelementptr inbounds i8, i8* %190, i64 0
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0)
%195 = sext i8 %194 to i32
%196 = icmp slt i32 %193, %195
br i1 %196, label %197, label %198
197: ; preds = %189
br label %212
198: ; preds = %189
%199 = load i8*, i8** %6
%200 = getelementptr inbounds i8, i8* %199, i64 0
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
%203 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0)
%204 = sext i8 %203 to i32
%205 = icmp sgt i32 %202, %204
br i1 %205, label %206, label %207
206: ; preds = %198
br label %210
207: ; preds = %198
%208 = load i8*, i8** %6
%209 = call i32 @strncmp(i8* %208, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i32 8)
br label %210
210: ; preds = %207, %206
%211 = phi i32 [ 1, %206 ], [ %209, %207 ]
br label %212
212: ; preds = %210, %197
%213 = phi i32 [ -1, %197 ], [ %211, %210 ]
%214 = icmp eq i32 %213, 0
br i1 %214, label %241, label %215
215: ; preds = %212
%216 = load i8*, i8** %6
%217 = getelementptr inbounds i8, i8* %216, i64 0
%218 = load i8, i8* %217
%219 = sext i8 %218 to i32
%220 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0)
%221 = sext i8 %220 to i32
%222 = icmp slt i32 %219, %221
br i1 %222, label %223, label %224
223: ; preds = %215
br label %238
224: ; preds = %215
%225 = load i8*, i8** %6
%226 = getelementptr inbounds i8, i8* %225, i64 0
%227 = load i8, i8* %226
%228 = sext i8 %227 to i32
%229 = load i8, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0)
%230 = sext i8 %229 to i32
%231 = icmp sgt i32 %228, %230
br i1 %231, label %232, label %233
232: ; preds = %224
br label %236
233: ; preds = %224
%234 = load i8*, i8** %6
%235 = call i32 @strncmp(i8* %234, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0), i32 8)
br label %236
236: ; preds = %233, %232
%237 = phi i32 [ 1, %232 ], [ %235, %233 ]
br label %238
238: ; preds = %236, %223
%239 = phi i32 [ -1, %223 ], [ %237, %236 ]
%240 = icmp eq i32 %239, 0
br i1 %240, label %241, label %283
241: ; preds = %238, %212, %186, %160, %134, %108
%242 = load i8*, i8** %8
%243 = icmp ne i8* %242, null
br i1 %243, label %244, label %280
244: ; preds = %241
%245 = load i64, i64* %12
%246 = icmp ugt i64 %245, 8
br i1 %246, label %247, label %279
247: ; preds = %244
%248 = load i8*, i8** %8
%249 = load i8*, i8** %6
%250 = getelementptr inbounds i8, i8* %249, i64 8
%251 = call i32 @strcpy(i8* %248, i8* %250)
%252 = load i64, i64* %12
%253 = sub i64 %252, 8
%254 = trunc i64 %253 to i32
store i32 %254, i32* %10
%255 = load i32, i32* %10
%256 = add nsw i32 %255, -1
store i32 %256, i32* %10
br label %257
257: ; preds = %275, %247
%258 = load i32, i32* %10
%259 = icmp sge i32 %258, 0
br i1 %259, label %260, label %278
260: ; preds = %257
%261 = load i8*, i8** %8
%262 = load i32, i32* %10
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %261, i64 %263
%265 = load i8, i8* %264
%266 = sext i8 %265 to i32
%267 = icmp eq i32 %266, 32
br i1 %267, label %268, label %273
268: ; preds = %260
%269 = load i8*, i8** %8
%270 = load i32, i32* %10
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
store i8 0, i8* %272
br label %274
273: ; preds = %260
br label %278
274: ; preds = %268
br label %275
275: ; preds = %274
%276 = load i32, i32* %10
%277 = add nsw i32 %276, -1
store i32 %277, i32* %10
br label %257
278: ; preds = %273, %257
br label %279
279: ; preds = %278, %244
br label %280
280: ; preds = %279, %241
%281 = load i32*, i32** %9
%282 = load i32, i32* %281
store i32 %282, i32* %5
br label %624
283: ; preds = %238
%284 = load i8*, i8** %6
%285 = getelementptr inbounds i8, i8* %284, i64 8
%286 = getelementptr inbounds i8, i8* %285, i64 0
%287 = load i8, i8* %286
%288 = sext i8 %287 to i32
%289 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0)
%290 = sext i8 %289 to i32
%291 = icmp slt i32 %288, %290
br i1 %291, label %292, label %293
292: ; preds = %283
br label %309
293: ; preds = %283
%294 = load i8*, i8** %6
%295 = getelementptr inbounds i8, i8* %294, i64 8
%296 = getelementptr inbounds i8, i8* %295, i64 0
%297 = load i8, i8* %296
%298 = sext i8 %297 to i32
%299 = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0)
%300 = sext i8 %299 to i32
%301 = icmp sgt i32 %298, %300
br i1 %301, label %302, label %303
302: ; preds = %293
br label %307
303: ; preds = %293
%304 = load i8*, i8** %6
%305 = getelementptr inbounds i8, i8* %304, i64 8
%306 = call i32 @strncmp(i8* %305, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32 2)
br label %307
307: ; preds = %303, %302
%308 = phi i32 [ 1, %302 ], [ %306, %303 ]
br label %309
309: ; preds = %307, %292
%310 = phi i32 [ -1, %292 ], [ %308, %307 ]
%311 = icmp eq i32 %310, 0
br i1 %311, label %312, label %313
312: ; preds = %309
store i64 10, i64* %14
br label %364
313: ; preds = %309
%314 = load i8*, i8** %6
%315 = call i64 @strcspn(i8* %314, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i64 %315, i64* %14
%316 = load i64, i64* %14
%317 = load i64, i64* %12
%318 = icmp eq i64 %316, %317
br i1 %318, label %319, label %361
319: ; preds = %313
%320 = load i8*, i8** %8
%321 = icmp ne i8* %320, null
br i1 %321, label %322, label %358
322: ; preds = %319
%323 = load i64, i64* %12
%324 = icmp ugt i64 %323, 8
br i1 %324, label %325, label %357
325: ; preds = %322
%326 = load i8*, i8** %8
%327 = load i8*, i8** %6
%328 = getelementptr inbounds i8, i8* %327, i64 8
%329 = call i32 @strcpy(i8* %326, i8* %328)
%330 = load i64, i64* %12
%331 = sub i64 %330, 8
%332 = trunc i64 %331 to i32
store i32 %332, i32* %10
%333 = load i32, i32* %10
%334 = add nsw i32 %333, -1
store i32 %334, i32* %10
br label %335
335: ; preds = %353, %325
%336 = load i32, i32* %10
%337 = icmp sge i32 %336, 0
br i1 %337, label %338, label %356
338: ; preds = %335
%339 = load i8*, i8** %8
%340 = load i32, i32* %10
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i8, i8* %339, i64 %341
%343 = load i8, i8* %342
%344 = sext i8 %343 to i32
%345 = icmp eq i32 %344, 32
br i1 %345, label %346, label %351
346: ; preds = %338
%347 = load i8*, i8** %8
%348 = load i32, i32* %10
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i8, i8* %347, i64 %349
store i8 0, i8* %350
br label %352
351: ; preds = %338
br label %356
352: ; preds = %346
br label %353
353: ; preds = %352
%354 = load i32, i32* %10
%355 = add nsw i32 %354, -1
store i32 %355, i32* %10
br label %335
356: ; preds = %351, %335
br label %357
357: ; preds = %356, %322
br label %358
358: ; preds = %357, %319
%359 = load i32*, i32** %9
%360 = load i32, i32* %359
store i32 %360, i32* %5
br label %624
361: ; preds = %313
%362 = load i64, i64* %14
%363 = add i64 %362, 1
store i64 %363, i64* %14
br label %364
364: ; preds = %361, %312
br label %365
365: ; preds = %364
br label %366
366: ; preds = %365, %105
%367 = load i8*, i8** %6
%368 = load i64, i64* %14
%369 = getelementptr inbounds i8, i8* %367, i64 %368
%370 = call i64 @strspn(i8* %369, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i64 %370, i64* %13
%371 = load i64, i64* %13
%372 = load i64, i64* %14
%373 = add i64 %371, %372
%374 = load i64, i64* %12
%375 = icmp eq i64 %373, %374
br i1 %375, label %376, label %379
376: ; preds = %366
%377 = load i32*, i32** %9
%378 = load i32, i32* %377
store i32 %378, i32* %5
br label %624
379: ; preds = %366
%380 = load i64, i64* %14
%381 = load i64, i64* %13
%382 = add i64 %380, %381
store i64 %382, i64* %11
%383 = load i8*, i8** %6
%384 = load i64, i64* %11
%385 = getelementptr inbounds i8, i8* %383, i64 %384
%386 = load i8, i8* %385
%387 = sext i8 %386 to i32
%388 = icmp eq i32 %387, 47
br i1 %388, label %389, label %392
389: ; preds = %379
%390 = load i64, i64* %11
%391 = add i64 %390, 1
store i64 %391, i64* %11
br label %554
392: ; preds = %379
%393 = load i8*, i8** %6
%394 = load i64, i64* %11
%395 = getelementptr inbounds i8, i8* %393, i64 %394
%396 = load i8, i8* %395
%397 = sext i8 %396 to i32
%398 = icmp eq i32 %397, 39
br i1 %398, label %399, label %497
399: ; preds = %392
%400 = load i8*, i8** %6
%401 = load i64, i64* %11
%402 = getelementptr inbounds i8, i8* %400, i64 %401
%403 = load i8, i8* %402
%404 = load i8*, i8** %7
%405 = getelementptr inbounds i8, i8* %404, i64 0
store i8 %403, i8* %405
store i32 1, i32* %10
%406 = load i64, i64* %11
%407 = add i64 %406, 1
store i64 %407, i64* %11
br label %408
408: ; preds = %459, %399
%409 = load i64, i64* %11
%410 = load i64, i64* %12
%411 = icmp ult i64 %409, %410
br i1 %411, label %412, label %464
412: ; preds = %408
%413 = load i8*, i8** %6
%414 = load i64, i64* %11
%415 = getelementptr inbounds i8, i8* %413, i64 %414
%416 = load i8, i8* %415
%417 = sext i8 %416 to i32
%418 = icmp eq i32 %417, 39
br i1 %418, label %419, label %450
419: ; preds = %412
%420 = load i8*, i8** %6
%421 = load i64, i64* %11
%422 = add i64 %421, 1
%423 = getelementptr inbounds i8, i8* %420, i64 %422
%424 = load i8, i8* %423
%425 = sext i8 %424 to i32
%426 = icmp eq i32 %425, 39
br i1 %426, label %427, label %440
427: ; preds = %419
%428 = load i8*, i8** %6
%429 = load i64, i64* %11
%430 = getelementptr inbounds i8, i8* %428, i64 %429
%431 = load i8, i8* %430
%432 = load i8*, i8** %7
%433 = load i32, i32* %10
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i8, i8* %432, i64 %434
store i8 %431, i8* %435
%436 = load i64, i64* %11
%437 = add i64 %436, 1
store i64 %437, i64* %11
%438 = load i32, i32* %10
%439 = add nsw i32 %438, 1
store i32 %439, i32* %10
br label %449
440: ; preds = %419
%441 = load i8*, i8** %6
%442 = load i64, i64* %11
%443 = getelementptr inbounds i8, i8* %441, i64 %442
%444 = load i8, i8* %443
%445 = load i8*, i8** %7
%446 = load i32, i32* %10
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i8, i8* %445, i64 %447
store i8 %444, i8* %448
br label %464
449: ; preds = %427
br label %450
450: ; preds = %449, %412
%451 = load i8*, i8** %6
%452 = load i64, i64* %11
%453 = getelementptr inbounds i8, i8* %451, i64 %452
%454 = load i8, i8* %453
%455 = load i8*, i8** %7
%456 = load i32, i32* %10
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds i8, i8* %455, i64 %457
store i8 %454, i8* %458
br label %459
459: ; preds = %450
%460 = load i64, i64* %11
%461 = add i64 %460, 1
store i64 %461, i64* %11
%462 = load i32, i32* %10
%463 = add nsw i32 %462, 1
store i32 %463, i32* %10
br label %408
464: ; preds = %440, %408
%465 = load i64, i64* %11
%466 = load i64, i64* %12
%467 = icmp eq i64 %465, %466
br i1 %467, label %468, label %488
468: ; preds = %464
%469 = load i32, i32* %10
%470 = icmp slt i32 %469, 69
br i1 %470, label %471, label %473
471: ; preds = %468
%472 = load i32, i32* %10
br label %474
473: ; preds = %468
br label %474
474: ; preds = %473, %471
%475 = phi i32 [ %472, %471 ], [ 69, %473 ]
store i32 %475, i32* %10
%476 = load i8*, i8** %7
%477 = load i32, i32* %10
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i8, i8* %476, i64 %478
store i8 39, i8* %479
%480 = load i8*, i8** %7
%481 = load i32, i32* %10
%482 = add nsw i32 %481, 1
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds i8, i8* %480, i64 %483
store i8 0, i8* %484
%485 = call i32 @ffpmsg(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.9, i64 0, i64 0))
%486 = load i8*, i8** %6
%487 = call i32 @ffpmsg(i8* %486)
br label %496
488: ; preds = %464
%489 = load i8*, i8** %7
%490 = load i32, i32* %10
%491 = add nsw i32 %490, 1
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds i8, i8* %489, i64 %492
store i8 0, i8* %493
%494 = load i64, i64* %11
%495 = add i64 %494, 1
store i64 %495, i64* %11
br label %496
496: ; preds = %488, %474
br label %553
497: ; preds = %392
%498 = load i8*, i8** %6
%499 = load i64, i64* %11
%500 = getelementptr inbounds i8, i8* %498, i64 %499
%501 = load i8, i8* %500
%502 = sext i8 %501 to i32
%503 = icmp eq i32 %502, 40
br i1 %503, label %504, label %535
504: ; preds = %497
%505 = load i8*, i8** %6
%506 = load i64, i64* %11
%507 = getelementptr inbounds i8, i8* %505, i64 %506
%508 = call i64 @strcspn(i8* %507, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
store i64 %508, i64* %13
%509 = load i64, i64* %13
%510 = load i8*, i8** %6
%511 = load i64, i64* %11
%512 = getelementptr inbounds i8, i8* %510, i64 %511
%513 = call i64 @strlen(i8* %512)
%514 = icmp eq i64 %509, %513
br i1 %514, label %515, label %520
515: ; preds = %504
%516 = call i32 @ffpmsg(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.11, i64 0, i64 0))
%517 = load i8*, i8** %6
%518 = call i32 @ffpmsg(i8* %517)
%519 = load i32*, i32** %9
store i32 205, i32* %519
store i32 205, i32* %5
br label %624
520: ; preds = %504
%521 = load i64, i64* %13
%522 = add i64 %521, 1
store i64 %522, i64* %13
%523 = load i8*, i8** %7
%524 = load i8*, i8** %6
%525 = load i64, i64* %11
%526 = getelementptr inbounds i8, i8* %524, i64 %525
%527 = load i64, i64* %13
%528 = call i32 @strncpy(i8* %523, i8* %526, i64 %527)
%529 = load i8*, i8** %7
%530 = load i64, i64* %13
%531 = getelementptr inbounds i8, i8* %529, i64 %530
store i8 0, i8* %531
%532 = load i64, i64* %11
%533 = load i64, i64* %13
%534 = add i64 %532, %533
store i64 %534, i64* %11
br label %552
535: ; preds = %497
%536 = load i8*, i8** %6
%537 = load i64, i64* %11
%538 = getelementptr inbounds i8, i8* %536, i64 %537
%539 = call i64 @strcspn(i8* %538, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
store i64 %539, i64* %13
%540 = load i8*, i8** %7
%541 = load i8*, i8** %6
%542 = load i64, i64* %11
%543 = getelementptr inbounds i8, i8* %541, i64 %542
%544 = load i64, i64* %13
%545 = call i32 @strncpy(i8* %540, i8* %543, i64 %544)
%546 = load i8*, i8** %7
%547 = load i64, i64* %13
%548 = getelementptr inbounds i8, i8* %546, i64 %547
store i8 0, i8* %548
%549 = load i64, i64* %11
%550 = load i64, i64* %13
%551 = add i64 %549, %550
store i64 %551, i64* %11
br label %552
552: ; preds = %535, %520
br label %553
553: ; preds = %552, %496
br label %554
554: ; preds = %553, %389
%555 = load i8*, i8** %8
%556 = icmp ne i8* %555, null
br i1 %556, label %557, label %621
557: ; preds = %554
%558 = load i8*, i8** %6
%559 = load i64, i64* %11
%560 = getelementptr inbounds i8, i8* %558, i64 %559
%561 = call i64 @strspn(i8* %560, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i64 %561, i64* %13
%562 = load i64, i64* %11
%563 = load i64, i64* %13
%564 = add i64 %562, %563
store i64 %564, i64* %11
%565 = load i64, i64* %11
%566 = icmp ult i64 %565, 80
br i1 %566, label %567, label %620
567: ; preds = %557
%568 = load i8*, i8** %6
%569 = load i64, i64* %11
%570 = getelementptr inbounds i8, i8* %568, i64 %569
%571 = load i8, i8* %570
%572 = sext i8 %571 to i32
%573 = icmp eq i32 %572, 47
br i1 %573, label %574, label %587
574: ; preds = %567
%575 = load i64, i64* %11
%576 = add i64 %575, 1
store i64 %576, i64* %11
%577 = load i8*, i8** %6
%578 = load i64, i64* %11
%579 = getelementptr inbounds i8, i8* %577, i64 %578
%580 = load i8, i8* %579
%581 = sext i8 %580 to i32
%582 = icmp eq i32 %581, 32
br i1 %582, label %583, label %586
583: ; preds = %574
%584 = load i64, i64* %11
%585 = add i64 %584, 1
store i64 %585, i64* %11
br label %586
586: ; preds = %583, %574
br label %587
587: ; preds = %586, %567
%588 = load i8*, i8** %8
%589 = load i8*, i8** %6
%590 = load i64, i64* %11
%591 = getelementptr inbounds i8, i8* %589, i64 %590
%592 = call i32 @strcat(i8* %588, i8* %591)
%593 = load i8*, i8** %8
%594 = call i64 @strlen(i8* %593)
%595 = trunc i64 %594 to i32
store i32 %595, i32* %10
%596 = load i32, i32* %10
%597 = add nsw i32 %596, -1
store i32 %597, i32* %10
br label %598
598: ; preds = %616, %587
%599 = load i32, i32* %10
%600 = icmp sge i32 %599, 0
br i1 %600, label %601, label %619
601: ; preds = %598
%602 = load i8*, i8** %8
%603 = load i32, i32* %10
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds i8, i8* %602, i64 %604
%606 = load i8, i8* %605
%607 = sext i8 %606 to i32
%608 = icmp eq i32 %607, 32
br i1 %608, label %609, label %614
609: ; preds = %601
%610 = load i8*, i8** %8
%611 = load i32, i32* %10
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds i8, i8* %610, i64 %612
store i8 0, i8* %613
br label %615
614: ; preds = %601
br label %619
615: ; preds = %609
br label %616
616: ; preds = %615
%617 = load i32, i32* %10
%618 = add nsw i32 %617, -1
store i32 %618, i32* %10
br label %598
619: ; preds = %614, %598
br label %620
620: ; preds = %619, %557
br label %621
621: ; preds = %620, %554
%622 = load i32*, i32** %9
%623 = load i32, i32* %622
store i32 %623, i32* %5
br label %624
624: ; preds = %621, %515, %376, %358, %280, %102, %18
%625 = load i32, i32* %5
ret i32 %625
}

LLVM IR (-O2):
@.str = [10 x i8] c"HIERARCH \00"
@.str.1 = [2 x i8] c"=\00"
@.str.2 = [9 x i8] c"COMMENT \00"
@.str.3 = [9 x i8] c"HISTORY \00"
@.str.4 = [9 x i8] c"END \00"
@.str.5 = [9 x i8] c"CONTINUE\00"
@.str.6 = [9 x i8] c" \00"
@.str.7 = [3 x i8] c"= \00"
@.str.8 = [2 x i8] c" \00"
@.str.9 = [48 x i8] c"This keyword string value has no closing quote:\00"
@.str.10 = [2 x i8] c")\00"
@.str.11 = [47 x i8] c"This complex keyword value has no closing ')':\00"
@.str.12 = [3 x i8] c" /\00"
define i32 @ffpsvc(i8* %0, i8* %1, i8* %2, i32* nocapture %3) {
%5 = load i32, i32* %3
%6 = icmp sgt i32 %5, 0
br i1 %6, label %246, label %7
7: ; preds = %4
store i8 0, i8* %1
%8 = icmp ne i8* %2, null
br i1 %8, label %9, label %10
9: ; preds = %7
store i8 0, i8* %2
br label %10
10: ; preds = %9, %7
%11 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%12 = load i8, i8* %0
%13 = icmp eq i8 %12, 72
br i1 %13, label %14, label %42
14: ; preds = %10
%15 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i32 9)
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %42
17: ; preds = %14
%18 = tail call i64 @strcspn(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%19 = icmp eq i64 %18, %11
br i1 %19, label %20, label %40
20: ; preds = %17
%21 = icmp ugt i64 %11, 8
%22 = select i1 %8, i1 %21, i1 false
br i1 %22, label %23, label %38
23: ; preds = %20
%24 = getelementptr inbounds i8, i8* %0, i64 8
%25 = tail call i32 @strcpy(i8* %2, i8* %24)
%26 = trunc i64 %11 to i32
%27 = add i32 %26, -9
%28 = icmp sgt i32 %27, -1
br i1 %28, label %29, label %38
29: ; preds = %23, %35
%30 = phi i32 [ %36, %35 ], [ %27, %23 ]
%31 = zext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %2, i64 %31
%33 = load i8, i8* %32
%34 = icmp eq i8 %33, 32
br i1 %34, label %35, label %38
35: ; preds = %29
store i8 0, i8* %32
%36 = add nsw i32 %30, -1
%37 = icmp sgt i32 %30, 0
br i1 %37, label %29, label %38
38: ; preds = %35, %29, %23, %20
%39 = load i32, i32* %3
br label %246
40: ; preds = %17
%41 = add i64 %18, 1
br label %129
42: ; preds = %10, %14
%43 = icmp ult i64 %11, 9
br i1 %43, label %98, label %44
44: ; preds = %42
%45 = load i8, i8* %0
%46 = icmp eq i8 %45, 67
br i1 %46, label %47, label %52
47: ; preds = %44
%48 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i32 8)
%49 = icmp eq i32 %48, 0
br i1 %49, label %82, label %50
50: ; preds = %47
%51 = load i8, i8* %0
br label %52
52: ; preds = %44, %50
%53 = phi i8 [ %51, %50 ], [ %45, %44 ]
%54 = icmp eq i8 %53, 72
br i1 %54, label %55, label %60
55: ; preds = %52
%56 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0), i32 8)
%57 = icmp eq i32 %56, 0
br i1 %57, label %82, label %58
58: ; preds = %55
%59 = load i8, i8* %0
br label %60
60: ; preds = %58, %52
%61 = phi i8 [ %59, %58 ], [ %53, %52 ]
%62 = icmp eq i8 %61, 69
br i1 %62, label %63, label %68
63: ; preds = %60
%64 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i32 8)
%65 = icmp eq i32 %64, 0
br i1 %65, label %82, label %66
66: ; preds = %63
%67 = load i8, i8* %0
br label %68
68: ; preds = %60, %66
%69 = phi i8 [ %67, %66 ], [ %61, %60 ]
%70 = icmp eq i8 %69, 67
br i1 %70, label %71, label %76
71: ; preds = %68
%72 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i32 8)
%73 = icmp eq i32 %72, 0
br i1 %73, label %82, label %74
74: ; preds = %71
%75 = load i8, i8* %0
br label %76
76: ; preds = %74, %68
%77 = phi i8 [ %75, %74 ], [ %69, %68 ]
%78 = icmp eq i8 %77, 32
br i1 %78, label %79, label %100
79: ; preds = %76
%80 = tail call i32 @strncmp(i8* %0, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0), i32 8)
%81 = icmp eq i32 %80, 0
br i1 %81, label %82, label %100
82: ; preds = %79, %71, %63, %55, %47
br i1 %8, label %83, label %98
83: ; preds = %82
%84 = getelementptr inbounds i8, i8* %0, i64 8
%85 = tail call i32 @strcpy(i8* %2, i8* %84)
%86 = trunc i64 %11 to i32
%87 = add i32 %86, -9
%88 = icmp sgt i32 %87, -1
br i1 %88, label %89, label %98
89: ; preds = %83, %95
%90 = phi i32 [ %96, %95 ], [ %87, %83 ]
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %2, i64 %91
%93 = load i8, i8* %92
%94 = icmp eq i8 %93, 32
br i1 %94, label %95, label %98
95: ; preds = %89
store i8 0, i8* %92
%96 = add nsw i32 %90, -1
%97 = icmp sgt i32 %90, 0
br i1 %97, label %89, label %98
98: ; preds = %95, %89, %83, %42, %82
%99 = load i32, i32* %3
br label %246
100: ; preds = %76, %79
%101 = getelementptr inbounds i8, i8* %0, i64 8
%102 = load i8, i8* %101
%103 = icmp eq i8 %102, 61
br i1 %103, label %104, label %107
104: ; preds = %100
%105 = tail call i32 @strncmp(i8* %101, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32 2)
%106 = icmp eq i32 %105, 0
br i1 %106, label %129, label %107
107: ; preds = %100, %104
%108 = tail call i64 @strcspn(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%109 = icmp eq i64 %108, %11
br i1 %109, label %110, label %127
110: ; preds = %107
br i1 %8, label %111, label %125
111: ; preds = %110
%112 = tail call i32 @strcpy(i8* %2, i8* %101)
%113 = trunc i64 %11 to i32
%114 = add i32 %113, -9
%115 = icmp sgt i32 %114, -1
br i1 %115, label %116, label %125
116: ; preds = %111, %122
%117 = phi i32 [ %123, %122 ], [ %114, %111 ]
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %2, i64 %118
%120 = load i8, i8* %119
%121 = icmp eq i8 %120, 32
br i1 %121, label %122, label %125
122: ; preds = %116
store i8 0, i8* %119
%123 = add nsw i32 %117, -1
%124 = icmp sgt i32 %117, 0
br i1 %124, label %116, label %125
125: ; preds = %122, %116, %111, %110
%126 = load i32, i32* %3
br label %246
127: ; preds = %107
%128 = add i64 %108, 1
br label %129
129: ; preds = %104, %127, %40
%130 = phi i64 [ %41, %40 ], [ %128, %127 ], [ 10, %104 ]
%131 = getelementptr inbounds i8, i8* %0, i64 %130
%132 = tail call i64 @strspn(i8* %131, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%133 = add i64 %132, %130
%134 = icmp eq i64 %133, %11
br i1 %134, label %135, label %137
135: ; preds = %129
%136 = load i32, i32* %3
br label %246
137: ; preds = %129
%138 = getelementptr inbounds i8, i8* %0, i64 %133
%139 = load i8, i8* %138
switch i8 %139, label %203 [
i8 47, label %140
i8 39, label %142
i8 40, label %191
]
140: ; preds = %137
%141 = add i64 %133, 1
br label %208
142: ; preds = %137
store i8 39, i8* %1
%143 = add i64 %133, 1
%144 = icmp ult i64 %143, %11
br i1 %144, label %145, label %171
145: ; preds = %142, %162
%146 = phi i64 [ %169, %162 ], [ %143, %142 ]
%147 = phi i64 [ %165, %162 ], [ %133, %142 ]
%148 = phi i32 [ %168, %162 ], [ 1, %142 ]
%149 = getelementptr inbounds i8, i8* %0, i64 %146
%150 = load i8, i8* %149
%151 = icmp eq i8 %150, 39
br i1 %151, label %152, label %162
152: ; preds = %145
%153 = add i64 %147, 2
%154 = getelementptr inbounds i8, i8* %0, i64 %153
%155 = load i8, i8* %154
%156 = icmp eq i8 %155, 39
%157 = sext i32 %148 to i64
%158 = getelementptr inbounds i8, i8* %1, i64 %157
store i8 39, i8* %158
br i1 %156, label %159, label %171
159: ; preds = %152
%160 = add nsw i32 %148, 1
%161 = load i8, i8* %154
br label %162
162: ; preds = %159, %145
%163 = phi i8 [ %161, %159 ], [ %150, %145 ]
%164 = phi i32 [ %160, %159 ], [ %148, %145 ]
%165 = phi i64 [ %153, %159 ], [ %146, %145 ]
%166 = sext i32 %164 to i64
%167 = getelementptr inbounds i8, i8* %1, i64 %166
store i8 %163, i8* %167
%168 = add nsw i32 %164, 1
%169 = add i64 %165, 1
%170 = icmp ult i64 %169, %11
br i1 %170, label %145, label %171
171: ; preds = %162, %152, %142
%172 = phi i32 [ 1, %142 ], [ %168, %162 ], [ %148, %152 ]
%173 = phi i64 [ %133, %142 ], [ %165, %162 ], [ %147, %152 ]
%174 = phi i64 [ %143, %142 ], [ %169, %162 ], [ %146, %152 ]
%175 = icmp eq i64 %174, %11
br i1 %175, label %176, label %186
176: ; preds = %171
%177 = icmp slt i32 %172, 69
%178 = select i1 %177, i32 %172, i32 69
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %1, i64 %179
store i8 39, i8* %180
%181 = add nsw i32 %178, 1
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %1, i64 %182
store i8 0, i8* %183
%184 = tail call i32 @ffpmsg(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.9, i64 0, i64 0))
%185 = tail call i32 @ffpmsg(i8* %0)
br label %208
186: ; preds = %171
%187 = add nsw i32 %172, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %1, i64 %188
store i8 0, i8* %189
%190 = add i64 %173, 2
br label %208
191: ; preds = %137
%192 = tail call i64 @strcspn(i8* %138, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.10, i64 0, i64 0))
%193 = tail call i64 @strlen(i8* %138)
%194 = icmp eq i64 %192, %193
br i1 %194, label %195, label %198
195: ; preds = %191
%196 = tail call i32 @ffpmsg(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.11, i64 0, i64 0))
%197 = tail call i32 @ffpmsg(i8* %0)
store i32 205, i32* %3
br label %246
198: ; preds = %191
%199 = add i64 %192, 1
%200 = tail call i32 @strncpy(i8* %1, i8* %138, i64 %199)
%201 = getelementptr inbounds i8, i8* %1, i64 %199
store i8 0, i8* %201
%202 = add i64 %199, %133
br label %208
203: ; preds = %137
%204 = tail call i64 @strcspn(i8* %138, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%205 = tail call i32 @strncpy(i8* %1, i8* %138, i64 %204)
%206 = getelementptr inbounds i8, i8* %1, i64 %204
store i8 0, i8* %206
%207 = add i64 %204, %133
br label %208
208: ; preds = %186, %176, %203, %198, %140
%209 = phi i64 [ %141, %140 ], [ %11, %176 ], [ %190, %186 ], [ %202, %198 ], [ %207, %203 ]
br i1 %8, label %210, label %244
210: ; preds = %208
%211 = getelementptr inbounds i8, i8* %0, i64 %209
%212 = tail call i64 @strspn(i8* %211, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%213 = add i64 %212, %209
%214 = icmp ult i64 %213, 80
br i1 %214, label %215, label %244
215: ; preds = %210
%216 = getelementptr inbounds i8, i8* %0, i64 %213
%217 = load i8, i8* %216
%218 = icmp eq i8 %217, 47
br i1 %218, label %219, label %226
219: ; preds = %215
%220 = add nuw nsw i64 %213, 1
%221 = getelementptr inbounds i8, i8* %0, i64 %220
%222 = load i8, i8* %221
%223 = icmp eq i8 %222, 32
%224 = add nuw nsw i64 %213, 2
%225 = select i1 %223, i64 %224, i64 %220
br label %226
226: ; preds = %219, %215
%227 = phi i64 [ %213, %215 ], [ %225, %219 ]
%228 = getelementptr inbounds i8, i8* %0, i64 %227
%229 = tail call i32 @strcat(i8* %2, i8* %228)
%230 = tail call i64 @strlen(i8* %2)
%231 = trunc i64 %230 to i32
%232 = icmp sgt i32 %231, 0
br i1 %232, label %233, label %244
233: ; preds = %226
%234 = and i64 %230, 4294967295
br label %235
235: ; preds = %233, %242
%236 = phi i64 [ %234, %233 ], [ %237, %242 ]
%237 = add nsw i64 %236, -1
%238 = and i64 %237, 4294967295
%239 = getelementptr inbounds i8, i8* %2, i64 %238
%240 = load i8, i8* %239
%241 = icmp eq i8 %240, 32
br i1 %241, label %242, label %244
242: ; preds = %235
store i8 0, i8* %239
%243 = icmp ugt i64 %236, 1
br i1 %243, label %235, label %244
244: ; preds = %242, %235, %226, %210, %208
%245 = load i32, i32* %3
br label %246
246: ; preds = %4, %244, %195, %135, %125, %98, %38
%247 = phi i32 [ %39, %38 ], [ %136, %135 ], [ %245, %244 ], [ 205, %195 ], [ %99, %98 ], [ %126, %125 ], [ %5, %4 ]
ret i32 %247
}