#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 */
scalar_t__ isalnum(char);
scalar_t__ isdigit(char);
scalar_t__ isspace(char);
int strlen(char *);
int /*<<< orphan*/ strncasecmp(char *, char *, int);
int parseSubject(char *subject, char **fnamep, int *partp, int *npartsp) {
  char *scan, *bak, *start;
  int part = -1, nparts = 0, hasdot = 0;
  if (!subject)
    return 1;
  scan = subject;
  while (*scan == ' ' || *scan == '\t' || *scan == '-')
    scan++;
  if (!strncasecmp(scan, "repost", 6)) {
    for (scan += 6;
         *scan == ' ' || *scan == '\t' || *scan == ':' || *scan == '-'; scan++)
      ;
  }
  if (!strncasecmp(scan, "re:", 3))
    return 1;
  do {
    while (*scan != '\n' && !isalnum(*scan) && *scan != '_')
      ++scan;
    *fnamep = start = scan;
    while (isalnum(*scan) || *scan == '-' || *scan == '+' || *scan == '&' ||
           *scan == '_' || *scan == '.') {
      if (*scan++ == '.')
        hasdot = 1;
    }
    if (!*scan || *scan == '\n')
      return 1;
  } while (start == scan ||
           (start[0] == 'v' && isdigit(start[1]) && *scan == ':'));
  *scan++ = '\0';
  if (!hasdot) {
    while (*(start = scan) != '\0' && *scan != '\n') {
      while (isspace(*start))
        ++start;
      for (scan = start; isalnum(*scan) || *scan == '-' || *scan == '+' ||
                         *scan == '&' || *scan == '_' || *scan == '.';
           ++scan) {
        if (*scan == '.' && (!isdigit(scan[-1]) || !isdigit(scan[1]))) {
          hasdot = 1;
        }
      }
      if (hasdot && scan > start) {
        *fnamep = start;
        *scan++ = '\0';
        break;
      }
      while (*scan && *scan != '\n' && !isalnum(*scan))
        ++scan;
    }
    scan = *fnamep + strlen(*fnamep) + 1;
  }
  while (*scan && *scan != '\n') {
    if (*scan == 'v' && isdigit(scan[1])) {
      ++scan;
      while (isdigit(*scan))
        ++scan;
    }
    if (isdigit(*scan) &&
        (scan[1] == '/' || (scan[1] == ' ' && scan[2] == '/') ||
         (scan[1] == ' ' && scan[2] == 'o' && scan[3] == 'f') ||
         (scan[1] == '-' && scan[2] == 'o' && scan[3] == 'f') ||
         (scan[1] == 'o' && isdigit(scan[2])))) {
      while (isdigit(scan[-1]))
        scan--;
      part = 0;
      while (isdigit(*scan)) {
        part = part * 10 + *scan++ - '0';
      }
      while (*scan != '\0' && *scan != '\n' && !isdigit(*scan))
        scan++;
      if (isdigit(*scan)) {
        nparts = 0;
        while (isdigit(*scan)) {
          nparts = nparts * 10 + *scan++ - '0';
        }
      }
      break;
    }
    if (!strncasecmp("part", scan, 4)) {
      if (scan[4] == 's') {
        for (bak = scan; bak >= subject && !isdigit(*bak); bak--)
          ;
        if (bak > subject) {
          while (bak > subject && isdigit(bak[-1]))
            bak--;
          nparts = 0;
          while (isdigit(*bak)) {
            nparts = nparts * 10 + *bak++ - '0';
          }
        }
      } else {
        while (*scan && *scan != '\n' && !isdigit(*scan))
          scan++;
        bak = scan - 1;
        if (isdigit(*scan)) {
          part = 0;
          do {
            part = part * 10 + *scan++ - '0';
          } while (isdigit(*scan));
        }
        scan = bak;
      }
    }
    scan++;
  }
  if (nparts == 0 || part == -1 || part > nparts)
    return 1;
  *partp = part;
  *npartsp = nparts;
  return 0;
}


x86 assembly (clang, -O0):
<parseSubject>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0xffffffff,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1194 <parseSubject+0x44>
movl   $0x1,-0x4(%rbp)
jmp    1be0 <parseSubject+0xa90>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x4d(%rbp)
je     11d6 <parseSubject+0x86>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x9,%ecx
mov    %al,-0x4d(%rbp)
je     11d6 <parseSubject+0x86>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
sete   %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    11e6 <parseSubject+0x96>
jmp    11f7 <parseSubject+0xa7>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    119c <parseSubject+0x4c>
mov    -0x30(%rbp),%rdi
lea    0xdfe(%rip),%rsi
mov    $0x6,%edx
call   1070 <strncasecmp@plt>
cmp    $0x0,%eax
jne    129b <parseSubject+0x14b>
mov    -0x30(%rbp),%rax
add    $0x6,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x4e(%rbp)
je     1270 <parseSubject+0x120>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x9,%ecx
mov    %al,-0x4e(%rbp)
je     1270 <parseSubject+0x120>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x3a,%ecx
mov    %al,-0x4e(%rbp)
je     1270 <parseSubject+0x120>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
sete   %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
test   $0x1,%al
jne    1280 <parseSubject+0x130>
jmp    1296 <parseSubject+0x146>
jmp    1285 <parseSubject+0x135>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1221 <parseSubject+0xd1>
jmp    129b <parseSubject+0x14b>
mov    -0x30(%rbp),%rdi
lea    0xd61(%rip),%rsi
mov    $0x3,%edx
call   1070 <strncasecmp@plt>
cmp    $0x0,%eax
jne    12c5 <parseSubject+0x175>
movl   $0x1,-0x4(%rbp)
jmp    1be0 <parseSubject+0xa90>
jmp    12ca <parseSubject+0x17a>
jmp    12cf <parseSubject+0x17f>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x4f(%rbp)
je     1312 <parseSubject+0x1c2>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isalnum@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x4f(%rbp)
jne    1312 <parseSubject+0x1c2>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
setne  %al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
test   $0x1,%al
jne    1322 <parseSubject+0x1d2>
jmp    1333 <parseSubject+0x1e3>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12cf <parseSubject+0x17f>
mov    -0x30(%rbp),%rcx
mov    %rcx,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isalnum@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x50(%rbp)
jne    13c4 <parseSubject+0x274>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2d,%ecx
mov    %al,-0x50(%rbp)
je     13c4 <parseSubject+0x274>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2b,%ecx
mov    %al,-0x50(%rbp)
je     13c4 <parseSubject+0x274>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x26,%ecx
mov    %al,-0x50(%rbp)
je     13c4 <parseSubject+0x274>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x5f,%ecx
mov    %al,-0x50(%rbp)
je     13c4 <parseSubject+0x274>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0x50(%rbp)
mov    -0x50(%rbp),%al
test   $0x1,%al
jne    13d4 <parseSubject+0x284>
jmp    13fb <parseSubject+0x2ab>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    13f6 <parseSubject+0x2a6>
movl   $0x1,-0x4c(%rbp)
jmp    1342 <parseSubject+0x1f2>
mov    -0x30(%rbp),%rax
cmpb   $0x0,(%rax)
je     1418 <parseSubject+0x2c8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1424 <parseSubject+0x2d4>
movl   $0x1,-0x4(%rbp)
jmp    1be0 <parseSubject+0xa90>
jmp    1429 <parseSubject+0x2d9>
mov    -0x40(%rbp),%rcx
mov    $0x1,%al
cmp    -0x30(%rbp),%rcx
mov    %al,-0x51(%rbp)
je     1486 <parseSubject+0x336>
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x76,%ecx
mov    %al,-0x52(%rbp)
jne    1480 <parseSubject+0x330>
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x52(%rbp)
je     1480 <parseSubject+0x330>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
sete   %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    12ca <parseSubject+0x17a>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
cmpl   $0x0,-0x4c(%rbp)
jne    16de <parseSubject+0x58e>
jmp    14b2 <parseSubject+0x362>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x53(%rbp)
je     14db <parseSubject+0x38b>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
test   $0x1,%al
jne    14eb <parseSubject+0x39b>
jmp    16b3 <parseSubject+0x563>
jmp    14f0 <parseSubject+0x3a0>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
je     1517 <parseSubject+0x3c7>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14f0 <parseSubject+0x3a0>
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isalnum@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x54(%rbp)
jne    15a1 <parseSubject+0x451>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2d,%ecx
mov    %al,-0x54(%rbp)
je     15a1 <parseSubject+0x451>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x2b,%ecx
mov    %al,-0x54(%rbp)
je     15a1 <parseSubject+0x451>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x26,%ecx
mov    %al,-0x54(%rbp)
je     15a1 <parseSubject+0x451>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x5f,%ecx
mov    %al,-0x54(%rbp)
je     15a1 <parseSubject+0x451>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
test   $0x1,%al
jne    15b1 <parseSubject+0x461>
jmp    160c <parseSubject+0x4bc>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    15f6 <parseSubject+0x4a6>
mov    -0x30(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     15ef <parseSubject+0x49f>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    15f6 <parseSubject+0x4a6>
movl   $0x1,-0x4c(%rbp)
jmp    15fb <parseSubject+0x4ab>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    151f <parseSubject+0x3cf>
cmpl   $0x0,-0x4c(%rbp)
je     1646 <parseSubject+0x4f6>
mov    -0x30(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    1646 <parseSubject+0x4f6>
mov    -0x40(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
jmp    16b3 <parseSubject+0x563>
jmp    164b <parseSubject+0x4fb>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x55(%rbp)
je     168d <parseSubject+0x53d>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x55(%rbp)
je     168d <parseSubject+0x53d>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isalnum@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    169d <parseSubject+0x54d>
jmp    16ae <parseSubject+0x55e>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    164b <parseSubject+0x4fb>
jmp    14b2 <parseSubject+0x362>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    16e3 <parseSubject+0x593>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x61(%rbp)
je     1708 <parseSubject+0x5b8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1718 <parseSubject+0x5c8>
jmp    1b9b <parseSubject+0xa4b>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x76,%eax
jne    1777 <parseSubject+0x627>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1777 <parseSubject+0x627>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1772 <parseSubject+0x622>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    174b <parseSubject+0x5fb>
jmp    1777 <parseSubject+0x627>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1983 <parseSubject+0x833>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2f,%eax
je     184e <parseSubject+0x6fe>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x20,%eax
jne    17c0 <parseSubject+0x670>
mov    -0x30(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x2f,%eax
je     184e <parseSubject+0x6fe>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x20,%eax
jne    17f3 <parseSubject+0x6a3>
mov    -0x30(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x6f,%eax
jne    17f3 <parseSubject+0x6a3>
mov    -0x30(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x66,%eax
je     184e <parseSubject+0x6fe>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2d,%eax
jne    1826 <parseSubject+0x6d6>
mov    -0x30(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x6f,%eax
jne    1826 <parseSubject+0x6d6>
mov    -0x30(%rbp),%rax
movsbl 0x3(%rax),%eax
cmp    $0x66,%eax
je     184e <parseSubject+0x6fe>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x6f,%eax
jne    1983 <parseSubject+0x833>
mov    -0x30(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1983 <parseSubject+0x833>
jmp    1853 <parseSubject+0x703>
mov    -0x30(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     187b <parseSubject+0x72b>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1853 <parseSubject+0x703>
movl   $0x0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     18bb <parseSubject+0x76b>
imul   $0xa,-0x44(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x44(%rbp)
jmp    1882 <parseSubject+0x732>
jmp    18c0 <parseSubject+0x770>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x62(%rbp)
je     1902 <parseSubject+0x7b2>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x62(%rbp)
je     1902 <parseSubject+0x7b2>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    1912 <parseSubject+0x7c2>
jmp    1923 <parseSubject+0x7d3>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    18c0 <parseSubject+0x770>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     197e <parseSubject+0x82e>
movl   $0x0,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1979 <parseSubject+0x829>
imul   $0xa,-0x48(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x48(%rbp)
jmp    1940 <parseSubject+0x7f0>
jmp    197e <parseSubject+0x82e>
jmp    1b9b <parseSubject+0xa4b>
mov    -0x30(%rbp),%rsi
lea    0x67d(%rip),%rdi
mov    $0x4,%edx
call   1070 <strncasecmp@plt>
cmp    $0x0,%eax
jne    1b8a <parseSubject+0xa3a>
mov    -0x30(%rbp),%rax
movsbl 0x4(%rax),%eax
cmp    $0x73,%eax
jne    1ab3 <parseSubject+0x963>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0x63(%rbp)
jb     19e5 <parseSubject+0x895>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    19f5 <parseSubject+0x8a5>
jmp    1a0b <parseSubject+0x8bb>
jmp    19fa <parseSubject+0x8aa>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    19ba <parseSubject+0x86a>
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jbe    1aae <parseSubject+0x95e>
jmp    1a1e <parseSubject+0x8ce>
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0x64(%rbp)
jbe    1a48 <parseSubject+0x8f8>
mov    -0x38(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x64(%rbp)
mov    -0x64(%rbp),%al
test   $0x1,%al
jne    1a58 <parseSubject+0x908>
jmp    1a69 <parseSubject+0x919>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    1a1e <parseSubject+0x8ce>
movl   $0x0,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1aa9 <parseSubject+0x959>
imul   $0xa,-0x48(%rbp),%eax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x48(%rbp)
jmp    1a70 <parseSubject+0x920>
jmp    1aae <parseSubject+0x95e>
jmp    1b85 <parseSubject+0xa35>
jmp    1ab8 <parseSubject+0x968>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x65(%rbp)
je     1afa <parseSubject+0x9aa>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x65(%rbp)
je     1afa <parseSubject+0x9aa>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
test   $0x1,%al
jne    1b0a <parseSubject+0x9ba>
jmp    1b1b <parseSubject+0x9cb>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1ab8 <parseSubject+0x968>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1b7d <parseSubject+0xa2d>
movl   $0x0,-0x44(%rbp)
imul   $0xa,-0x44(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1b44 <parseSubject+0x9f4>
jmp    1b7d <parseSubject+0xa2d>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1b8a <parseSubject+0xa3a>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    16e3 <parseSubject+0x593>
cmpl   $0x0,-0x48(%rbp)
je     1bbb <parseSubject+0xa6b>
cmpl   $0xffffffff,-0x44(%rbp)
je     1bbb <parseSubject+0xa6b>
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jle    1bc7 <parseSubject+0xa77>
movl   $0x1,-0x4(%rbp)
jmp    1be0 <parseSubject+0xa90>
mov    -0x44(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseSubject>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,0x20(%rsp)
mov    $0x1,%r13d
test   %rdi,%rdi
je     16da <parseSubject+0x58a>
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rdi,%rbx
movabs $0x200100000200,%rax
mov    %rdi,%rbp
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%r12d
cmp    $0x2d,%r12
ja     11a7 <parseSubject+0x57>
bt     %r12,%rax
jae    11a7 <parseSubject+0x57>
add    $0x1,%rbp
jmp    1190 <parseSubject+0x40>
lea    0xe76(%rip),%rsi
mov    %rbp,%rdi
mov    $0x6,%edx
call   1070 <strncasecmp@plt>
test   %eax,%eax
je     13ac <parseSubject+0x25c>
lea    0xe61(%rip),%rsi
mov    %rbp,%rdi
mov    $0x3,%edx
call   1070 <strncasecmp@plt>
test   %eax,%eax
je     16da <parseSubject+0x58a>
mov    %rbx,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
xor    %ebx,%ebx
mov    $0x1,%r13d
cs nopw 0x0(%rax,%rax,1)
cmp    $0xa,%r12b
je     1224 <parseSubject+0xd4>
movsbl %r12b,%edi
call   1050 <isalnum@plt>
test   %rax,%rax
jne    1224 <parseSubject+0xd4>
cmpb   $0x5f,0x0(%rbp)
je     1224 <parseSubject+0xd4>
mov    0x1(%rbp),%r12b
add    $0x1,%rbp
jmp    1200 <parseSubject+0xb0>
mov    0x20(%rsp),%rax
mov    %rbp,(%rax)
xor    %r14d,%r14d
mov    %rbp,%r15
jmp    1250 <parseSubject+0x100>
cmp    $0x5f,%r12b
jne    128d <parseSubject+0x13d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    $0x2e,%r12b
cmove  %r13d,%ebx
add    $0xffffffffffffffff,%r14
movsbl (%r15),%edi
call   1050 <isalnum@plt>
movzbl (%r15),%r12d
test   %rax,%rax
jne    1240 <parseSubject+0xf0>
cmp    $0x2e,%r12b
ja     1234 <parseSubject+0xe4>
movzbl %r12b,%eax
movabs $0x684000000000,%rcx
bt     %rax,%rcx
jb     1240 <parseSubject+0xf0>
mov    $0x401,%ecx
bt     %rax,%rcx
jb     16d4 <parseSubject+0x584>
jmp    1234 <parseSubject+0xe4>
test   %r14,%r14
je     1200 <parseSubject+0xb0>
cmpb   $0x76,0x0(%rbp)
jne    12ba <parseSubject+0x16a>
movsbl 0x1(%rbp),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12ba <parseSubject+0x16a>
mov    $0x3a,%r12b
cmpb   $0x3a,(%r15)
mov    %r15,%rbp
je     1200 <parseSubject+0xb0>
movb   $0x0,(%r15)
add    $0x1,%r15
test   %ebx,%ebx
jne    1404 <parseSubject+0x2b4>
xor    %r14d,%r14d
lea    0xd2c(%rip),%rbp
mov    (%r15),%al
test   %al,%al
je     13ea <parseSubject+0x29a>
cmp    $0xa,%al
je     13ea <parseSubject+0x29a>
movsbl %al,%edi
nopw   0x0(%rax,%rax,1)
call   1060 <isspace@plt>
test   %rax,%rax
je     1305 <parseSubject+0x1b5>
movsbl 0x1(%r15),%edi
add    $0x1,%r15
jmp    12f0 <parseSubject+0x1a0>
mov    %r15,%rbx
jmp    131a <parseSubject+0x1ca>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%r14d
add    $0x1,%rbx
movsbl (%rbx),%edi
call   1050 <isalnum@plt>
movzbl (%rbx),%ecx
test   %rax,%rax
je     1350 <parseSubject+0x200>
cmp    $0x2e,%cl
jne    1316 <parseSubject+0x1c6>
movsbl -0x1(%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1310 <parseSubject+0x1c0>
movsbl 0x1(%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    1316 <parseSubject+0x1c6>
jmp    1310 <parseSubject+0x1c0>
nopl   (%rax)
lea    -0x26(%rcx),%eax
cmp    $0x8,%al
ja     1364 <parseSubject+0x214>
movzbl %al,%eax
movslq 0x0(%rbp,%rax,4),%rax
add    %rbp,%rax
jmp    *%rax
cmp    $0x5f,%cl
je     1316 <parseSubject+0x1c6>
cmp    %r15,%rbx
jbe    1373 <parseSubject+0x223>
test   %r14d,%r14d
jne    13df <parseSubject+0x28f>
mov    %rbx,%r15
test   %cl,%cl
je     12d4 <parseSubject+0x184>
xchg   %ax,%ax
cmp    $0xa,%cl
je     12d4 <parseSubject+0x184>
movsbl %cl,%edi
call   1050 <isalnum@plt>
test   %rax,%rax
jne    12d4 <parseSubject+0x184>
movzbl 0x1(%r15),%ecx
add    $0x1,%r15
test   %cl,%cl
jne    1380 <parseSubject+0x230>
jmp    12d4 <parseSubject+0x184>
add    $0x6,%rbp
movabs $0x400200100000200,%rax
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%r12d
cmp    $0x3a,%r12
ja     11c3 <parseSubject+0x73>
bt     %r12,%rax
jae    11c3 <parseSubject+0x73>
add    $0x1,%rbp
jmp    13c0 <parseSubject+0x270>
mov    0x20(%rsp),%rax
mov    %r15,(%rax)
movb   $0x0,(%rbx)
mov    0x20(%rsp),%rax
mov    (%rax),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
lea    (%rbx,%rax,1),%r15
add    $0x1,%r15
xor    %r12d,%r12d
mov    $0xffffffff,%r14d
lea    0xc1b(%rip),%r13
jmp    1448 <parseSubject+0x2f8>
mov    0x2(%r15),%al
cmp    $0x6f,%al
je     1488 <parseSubject+0x338>
cmp    $0x2f,%al
je     15f6 <parseSubject+0x4a6>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r15,%rsi
mov    $0x4,%edx
call   1070 <strncasecmp@plt>
test   %eax,%eax
je     14b5 <parseSubject+0x365>
add    $0x1,%r15
mov    (%r15),%al
cmp    $0x76,%al
je     1494 <parseSubject+0x344>
test   %al,%al
je     16a9 <parseSubject+0x559>
cmp    $0xa,%al
je     16a9 <parseSubject+0x559>
movsbl (%r15),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1430 <parseSubject+0x2e0>
mov    0x1(%r15),%al
cmp    $0x2e,%al
jg     156d <parseSubject+0x41d>
cmp    $0x20,%al
je     1416 <parseSubject+0x2c6>
cmp    $0x2d,%al
jne    1430 <parseSubject+0x2e0>
cmpb   $0x6f,0x2(%r15)
jne    1430 <parseSubject+0x2e0>
cmpb   $0x66,0x3(%r15)
jne    1430 <parseSubject+0x2e0>
jmp    15f6 <parseSubject+0x4a6>
movsbl 0x1(%r15),%edi
nopl   0x0(%rax)
call   1030 <isdigit@plt>
test   %rax,%rax
je     145f <parseSubject+0x30f>
movsbl 0x1(%r15),%edi
add    $0x1,%r15
jmp    14a0 <parseSubject+0x350>
cmpb   $0x73,0x4(%r15)
jne    158a <parseSubject+0x43a>
mov    %r15,%rbp
cmp    0x8(%rsp),%r15
jb     14e9 <parseSubject+0x399>
mov    %r15,%rbp
nopl   (%rax)
movsbl 0x0(%rbp),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    14e9 <parseSubject+0x399>
add    $0xffffffffffffffff,%rbp
cmp    0x8(%rsp),%rbp
jae    14d0 <parseSubject+0x380>
cmp    0x8(%rsp),%rbp
jbe    1444 <parseSubject+0x2f4>
lea    0x1(%rbp),%rcx
mov    0x8(%rsp),%r13
nopl   (%rax)
mov    %rbp,%r12
mov    %rcx,%rbx
cmp    %r13,%rbp
jbe    1524 <parseSubject+0x3d4>
lea    -0x1(%r12),%rbp
movsbl -0x1(%r12),%edi
call   1030 <isdigit@plt>
lea    -0x1(%rbx),%rcx
test   %rax,%rax
jne    1500 <parseSubject+0x3b0>
movsbl (%r12),%edi
call   1030 <isdigit@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     1561 <parseSubject+0x411>
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%r12,4),%eax
movsbl -0x1(%rbx),%ecx
lea    (%rcx,%rax,2),%r12d
add    $0xffffffd0,%r12d
movsbl (%rbx),%edi
call   1030 <isdigit@plt>
add    $0x1,%rbx
test   %rax,%rax
jne    1540 <parseSubject+0x3f0>
lea    0xac7(%rip),%r13
jmp    1444 <parseSubject+0x2f4>
cmp    $0x6f,%al
jne    141e <parseSubject+0x2ce>
movsbl 0x2(%r15),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1430 <parseSubject+0x2e0>
jmp    15f6 <parseSubject+0x4a6>
lea    0x1(%r15),%rbx
xchg   %ax,%ax
movzbl (%r15),%eax
test   %al,%al
je     15b6 <parseSubject+0x466>
cmp    $0xa,%al
je     15b6 <parseSubject+0x466>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    15b3 <parseSubject+0x463>
add    $0x1,%r15
add    $0x1,%rbx
jmp    1590 <parseSubject+0x440>
mov    (%r15),%al
add    $0xffffffffffffffff,%r15
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1444 <parseSubject+0x2f4>
xor    %r14d,%r14d
xchg   %ax,%ax
lea    (%r14,%r14,4),%eax
movsbl -0x1(%rbx),%ecx
lea    (%rcx,%rax,2),%r14d
add    $0xffffffd0,%r14d
movsbl (%rbx),%edi
call   1030 <isdigit@plt>
add    $0x1,%rbx
test   %rax,%rax
jne    15d0 <parseSubject+0x480>
jmp    1444 <parseSubject+0x2f4>
add    $0x1,%r15
movsbl -0x2(%r15),%edi
call   1030 <isdigit@plt>
add    $0xffffffffffffffff,%r15
test   %rax,%rax
jne    15fa <parseSubject+0x4aa>
movsbl (%r15),%edi
call   1030 <isdigit@plt>
xor    %r14d,%r14d
test   %rax,%rax
je     1645 <parseSubject+0x4f5>
mov    %r15,%rcx
lea    (%r14,%r14,4),%eax
lea    0x1(%rcx),%r15
movsbl (%rcx),%edx
lea    (%rdx,%rax,2),%r14d
add    $0xffffffd0,%r14d
movsbl 0x1(%rcx),%edi
call   1030 <isdigit@plt>
mov    %r15,%rcx
test   %rax,%rax
jne    1621 <parseSubject+0x4d1>
add    $0x1,%r15
movzbl -0x1(%r15),%eax
test   %al,%al
je     1667 <parseSubject+0x517>
cmp    $0xa,%al
je     1667 <parseSubject+0x517>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1645 <parseSubject+0x4f5>
mov    -0x1(%r15),%al
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     16a9 <parseSubject+0x559>
movsbl -0x1(%r15),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     16d4 <parseSubject+0x584>
xor    %r12d,%r12d
lea    (%r12,%r12,4),%eax
movsbl -0x1(%r15),%ecx
lea    (%rcx,%rax,2),%r12d
add    $0xffffffd0,%r12d
movsbl (%r15),%edi
call   1030 <isdigit@plt>
add    $0x1,%r15
test   %rax,%rax
jne    1686 <parseSubject+0x536>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%rcx
mov    $0x1,%r13d
test   %r12d,%r12d
je     16da <parseSubject+0x58a>
cmp    $0xffffffff,%r14d
je     16da <parseSubject+0x58a>
cmp    %r12d,%r14d
jg     16da <parseSubject+0x58a>
mov    %r14d,(%rcx)
mov    %r12d,(%rax)
xor    %r13d,%r13d
jmp    16da <parseSubject+0x58a>
mov    $0x1,%r13d
mov    %r13d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [7 x i8] c"repost\00"
@.str.1 = [4 x i8] c"re:\00"
@.str.2 = [5 x i8] c"part\00"
define i32 @parseSubject(i8* %0, i8** nocapture %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3) {
%5 = icmp eq i8* %0, null
br i1 %5, label %323, label %6
6: ; preds = %4, %9
%7 = phi i8* [ %10, %9 ], [ %0, %4 ]
%8 = load i8, i8* %7
switch i8 %8, label %11 [
i8 32, label %9
i8 9, label %9
i8 45, label %9
]
9: ; preds = %6, %6, %6
%10 = getelementptr inbounds i8, i8* %7, i64 1
br label %6
11: ; preds = %6
%12 = tail call i32 @strncasecmp(i8* %7, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 6)
%13 = icmp eq i32 %12, 0
br i1 %13, label %14, label %21
14: ; preds = %11
%15 = getelementptr inbounds i8, i8* %7, i64 6
br label %16
16: ; preds = %19, %14
%17 = phi i8* [ %15, %14 ], [ %20, %19 ]
%18 = load i8, i8* %17
switch i8 %18, label %21 [
i8 32, label %19
i8 9, label %19
i8 58, label %19
i8 45, label %19
]
19: ; preds = %16, %16, %16, %16
%20 = getelementptr inbounds i8, i8* %17, i64 1
br label %16
21: ; preds = %16, %11
%22 = phi i8 [ %8, %11 ], [ %18, %16 ]
%23 = phi i8* [ %7, %11 ], [ %17, %16 ]
%24 = tail call i32 @strncasecmp(i8* %23, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 3)
%25 = icmp eq i32 %24, 0
br i1 %25, label %323, label %26
26: ; preds = %21, %70
%27 = phi i8 [ %71, %70 ], [ %22, %21 ]
%28 = phi i8* [ %72, %70 ], [ %23, %21 ]
%29 = phi i32 [ %47, %70 ], [ 0, %21 ]
%30 = icmp eq i8 %27, 10
br i1 %30, label %43, label %31
31: ; preds = %26, %39
%32 = phi i8 [ %41, %39 ], [ %27, %26 ]
%33 = phi i8* [ %40, %39 ], [ %28, %26 ]
%34 = tail call i64 @isalnum(i8 signext %32)
%35 = icmp eq i64 %34, 0
br i1 %35, label %36, label %43
36: ; preds = %31
%37 = load i8, i8* %33
%38 = icmp eq i8 %37, 95
br i1 %38, label %43, label %39
39: ; preds = %36
%40 = getelementptr inbounds i8, i8* %33, i64 1
%41 = load i8, i8* %40
%42 = icmp eq i8 %41, 10
br i1 %42, label %43, label %31
43: ; preds = %36, %31, %39, %26
%44 = phi i8* [ %28, %26 ], [ %40, %39 ], [ %33, %31 ], [ %33, %36 ]
store i8* %44, i8** %1
br label %45
45: ; preds = %53, %43
%46 = phi i8* [ %44, %43 ], [ %54, %53 ]
%47 = phi i32 [ %29, %43 ], [ %56, %53 ]
%48 = load i8, i8* %46
%49 = tail call i64 @isalnum(i8 signext %48)
%50 = icmp eq i64 %49, 0
%51 = load i8, i8* %46
br i1 %50, label %52, label %53
52: ; preds = %45
switch i8 %51, label %57 [
i8 45, label %53
i8 43, label %53
i8 38, label %53
i8 95, label %53
i8 46, label %53
i8 0, label %323
i8 10, label %323
]
53: ; preds = %45, %52, %52, %52, %52, %52
%54 = getelementptr inbounds i8, i8* %46, i64 1
%55 = icmp eq i8 %51, 46
%56 = select i1 %55, i32 1, i32 %47
br label %45
57: ; preds = %52
%58 = icmp eq i8* %44, %46
br i1 %58, label %70, label %59
59: ; preds = %57
%60 = load i8, i8* %44
%61 = icmp eq i8 %60, 118
br i1 %61, label %62, label %73
62: ; preds = %59
%63 = getelementptr inbounds i8, i8* %44, i64 1
%64 = load i8, i8* %63
%65 = tail call i64 @isdigit(i8 signext %64)
%66 = icmp eq i64 %65, 0
br i1 %66, label %73, label %67
67: ; preds = %62
%68 = load i8, i8* %46
%69 = icmp eq i8 %68, 58
br i1 %69, label %70, label %73
70: ; preds = %67, %57
%71 = phi i8 [ 58, %67 ], [ %51, %57 ]
%72 = phi i8* [ %46, %67 ], [ %44, %57 ]
br label %26
73: ; preds = %59, %62, %67
%74 = getelementptr inbounds i8, i8* %46, i64 1
store i8 0, i8* %46
%75 = icmp eq i32 %47, 0
br i1 %75, label %77, label %136
76: ; preds = %121, %121, %124
br label %77
77: ; preds = %73, %76
%78 = phi i8* [ %123, %76 ], [ %74, %73 ]
%79 = phi i32 [ %94, %76 ], [ 0, %73 ]
%80 = load i8, i8* %78
switch i8 %80, label %81 [
i8 0, label %130
i8 10, label %130
]
81: ; preds = %77
%82 = tail call i64 @isspace(i8 signext %80)
%83 = icmp eq i64 %82, 0
br i1 %83, label %90, label %84
84: ; preds = %81, %84
%85 = phi i8* [ %86, %84 ], [ %78, %81 ]
%86 = getelementptr inbounds i8, i8* %85, i64 1
%87 = load i8, i8* %86
%88 = tail call i64 @isspace(i8 signext %87)
%89 = icmp eq i64 %88, 0
br i1 %89, label %90, label %84
90: ; preds = %84, %81
%91 = phi i8* [ %78, %81 ], [ %86, %84 ]
br label %92
92: ; preds = %90, %113
%93 = phi i8* [ %115, %113 ], [ %91, %90 ]
%94 = phi i32 [ %114, %113 ], [ %79, %90 ]
%95 = load i8, i8* %93
%96 = tail call i64 @isalnum(i8 signext %95)
%97 = icmp eq i64 %96, 0
%98 = load i8, i8* %93
br i1 %97, label %99, label %100
99: ; preds = %92
switch i8 %98, label %116 [
i8 46, label %102
i8 38, label %113
i8 43, label %113
i8 45, label %113
i8 95, label %113
]
100: ; preds = %92
%101 = icmp eq i8 %98, 46
br i1 %101, label %102, label %113
102: ; preds = %99, %100
%103 = getelementptr inbounds i8, i8* %93, i64 -1
%104 = load i8, i8* %103
%105 = tail call i64 @isdigit(i8 signext %104)
%106 = icmp eq i64 %105, 0
br i1 %106, label %112, label %107
107: ; preds = %102
%108 = getelementptr inbounds i8, i8* %93, i64 1
%109 = load i8, i8* %108
%110 = tail call i64 @isdigit(i8 signext %109)
%111 = icmp eq i64 %110, 0
br i1 %111, label %112, label %113
112: ; preds = %107, %102
br label %113
113: ; preds = %99, %99, %99, %99, %100, %107, %112
%114 = phi i32 [ %94, %107 ], [ 1, %112 ], [ %94, %100 ], [ %94, %99 ], [ %94, %99 ], [ %94, %99 ], [ %94, %99 ]
%115 = getelementptr inbounds i8, i8* %93, i64 1
br label %92
116: ; preds = %99
%117 = icmp ne i32 %94, 0
%118 = icmp ugt i8* %93, %91
%119 = and i1 %118, %117
br i1 %119, label %120, label %121
120: ; preds = %116
store i8* %91, i8** %1
store i8 0, i8* %93
br label %130
121: ; preds = %116, %127
%122 = phi i8 [ %129, %127 ], [ %98, %116 ]
%123 = phi i8* [ %128, %127 ], [ %93, %116 ]
switch i8 %122, label %124 [
i8 0, label %76
i8 10, label %76
]
124: ; preds = %121
%125 = tail call i64 @isalnum(i8 signext %122)
%126 = icmp eq i64 %125, 0
br i1 %126, label %127, label %76
127: ; preds = %124
%128 = getelementptr inbounds i8, i8* %123, i64 1
%129 = load i8, i8* %128
br label %121
130: ; preds = %77, %77, %120
%131 = load i8*, i8** %1
%132 = tail call i32 @strlen(i8* %131)
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = getelementptr inbounds i8, i8* %134, i64 1
br label %136
136: ; preds = %130, %73
%137 = phi i8* [ %135, %130 ], [ %74, %73 ]
br label %138
138: ; preds = %136, %309
%139 = phi i8* [ %313, %309 ], [ %137, %136 ]
%140 = phi i32 [ %311, %309 ], [ -1, %136 ]
%141 = phi i32 [ %312, %309 ], [ 0, %136 ]
%142 = load i8, i8* %139
switch i8 %142, label %154 [
i8 0, label %314
i8 10, label %314
i8 118, label %143
]
143: ; preds = %138
%144 = getelementptr inbounds i8, i8* %139, i64 1
%145 = load i8, i8* %144
%146 = tail call i64 @isdigit(i8 signext %145)
%147 = icmp eq i64 %146, 0
br i1 %147, label %154, label %148
148: ; preds = %143, %148
%149 = phi i8* [ %150, %148 ], [ %139, %143 ]
%150 = getelementptr inbounds i8, i8* %149, i64 1
%151 = load i8, i8* %150
%152 = tail call i64 @isdigit(i8 signext %151)
%153 = icmp eq i64 %152, 0
br i1 %153, label %154, label %148
154: ; preds = %148, %138, %143
%155 = phi i8* [ %139, %143 ], [ %139, %138 ], [ %150, %148 ]
%156 = load i8, i8* %155
%157 = tail call i64 @isdigit(i8 signext %156)
%158 = icmp eq i64 %157, 0
br i1 %158, label %238, label %159
159: ; preds = %154
%160 = getelementptr inbounds i8, i8* %155, i64 1
%161 = load i8, i8* %160
switch i8 %161, label %238 [
i8 47, label %182
i8 32, label %162
i8 45, label %169
i8 111, label %177
]
162: ; preds = %159
%163 = getelementptr inbounds i8, i8* %155, i64 2
%164 = load i8, i8* %163
switch i8 %164, label %238 [
i8 47, label %182
i8 111, label %165
]
165: ; preds = %162
%166 = getelementptr inbounds i8, i8* %155, i64 3
%167 = load i8, i8* %166
%168 = icmp eq i8 %167, 102
br i1 %168, label %182, label %238
169: ; preds = %159
%170 = getelementptr inbounds i8, i8* %155, i64 2
%171 = load i8, i8* %170
%172 = icmp eq i8 %171, 111
br i1 %172, label %173, label %238
173: ; preds = %169
%174 = getelementptr inbounds i8, i8* %155, i64 3
%175 = load i8, i8* %174
%176 = icmp eq i8 %175, 102
br i1 %176, label %182, label %238
177: ; preds = %159
%178 = getelementptr inbounds i8, i8* %155, i64 2
%179 = load i8, i8* %178
%180 = tail call i64 @isdigit(i8 signext %179)
%181 = icmp eq i64 %180, 0
br i1 %181, label %238, label %182
182: ; preds = %162, %159, %177, %173, %165
br label %183
183: ; preds = %182, %183
%184 = phi i8* [ %185, %183 ], [ %155, %182 ]
%185 = getelementptr inbounds i8, i8* %184, i64 -1
%186 = load i8, i8* %185
%187 = tail call i64 @isdigit(i8 signext %186)
%188 = icmp eq i64 %187, 0
br i1 %188, label %189, label %183
189: ; preds = %183
%190 = load i8, i8* %184
%191 = tail call i64 @isdigit(i8 signext %190)
%192 = icmp eq i64 %191, 0
br i1 %192, label %193, label %196
193: ; preds = %196, %189
%194 = phi i8* [ %184, %189 ], [ %200, %196 ]
%195 = phi i32 [ 0, %189 ], [ %204, %196 ]
br label %208
196: ; preds = %189, %196
%197 = phi i32 [ %204, %196 ], [ 0, %189 ]
%198 = phi i8* [ %200, %196 ], [ %184, %189 ]
%199 = mul nsw i32 %197, 10
%200 = getelementptr inbounds i8, i8* %198, i64 1
%201 = load i8, i8* %198
%202 = sext i8 %201 to i32
%203 = add i32 %199, -48
%204 = add i32 %203, %202
%205 = load i8, i8* %200
%206 = tail call i64 @isdigit(i8 signext %205)
%207 = icmp eq i64 %206, 0
br i1 %207, label %193, label %196
208: ; preds = %193, %216
%209 = phi i8* [ %217, %216 ], [ %194, %193 ]
%210 = load i8, i8* %209
switch i8 %210, label %211 [
i8 0, label %218
i8 10, label %218
]
211: ; preds = %208
%212 = tail call i64 @isdigit(i8 signext %210)
%213 = icmp eq i64 %212, 0
br i1 %213, label %216, label %214
214: ; preds = %211
%215 = load i8, i8* %209
br label %218
216: ; preds = %211
%217 = getelementptr inbounds i8, i8* %209, i64 1
br label %208
218: ; preds = %208, %208, %214
%219 = phi i8 [ %215, %214 ], [ %210, %208 ], [ %210, %208 ]
%220 = tail call i64 @isdigit(i8 signext %219)
%221 = icmp eq i64 %220, 0
br i1 %221, label %314, label %222
222: ; preds = %218
%223 = load i8, i8* %209
%224 = tail call i64 @isdigit(i8 signext %223)
%225 = icmp eq i64 %224, 0
br i1 %225, label %323, label %226
226: ; preds = %222, %226
%227 = phi i32 [ %234, %226 ], [ 0, %222 ]
%228 = phi i8* [ %230, %226 ], [ %209, %222 ]
%229 = mul nsw i32 %227, 10
%230 = getelementptr inbounds i8, i8* %228, i64 1
%231 = load i8, i8* %228
%232 = sext i8 %231 to i32
%233 = add i32 %229, -48
%234 = add i32 %233, %232
%235 = load i8, i8* %230
%236 = tail call i64 @isdigit(i8 signext %235)
%237 = icmp eq i64 %236, 0
br i1 %237, label %314, label %226
238: ; preds = %162, %159, %165, %169, %173, %177, %154
%239 = tail call i32 @strncasecmp(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8* %155, i32 4)
%240 = icmp eq i32 %239, 0
br i1 %240, label %241, label %309
241: ; preds = %238
%242 = getelementptr inbounds i8, i8* %155, i64 4
%243 = load i8, i8* %242
%244 = icmp eq i8 %243, 115
br i1 %244, label %245, label %282
245: ; preds = %241
%246 = icmp ult i8* %155, %0
br i1 %246, label %255, label %247
247: ; preds = %245, %252
%248 = phi i8* [ %253, %252 ], [ %155, %245 ]
%249 = load i8, i8* %248
%250 = tail call i64 @isdigit(i8 signext %249)
%251 = icmp eq i64 %250, 0
br i1 %251, label %252, label %255
252: ; preds = %247
%253 = getelementptr inbounds i8, i8* %248, i64 -1
%254 = icmp ult i8* %253, %0
br i1 %254, label %255, label %247
255: ; preds = %247, %252, %245
%256 = phi i8* [ %155, %245 ], [ %253, %252 ], [ %248, %247 ]
%257 = icmp ugt i8* %256, %0
br i1 %257, label %258, label %309
258: ; preds = %255, %261
%259 = phi i8* [ %262, %261 ], [ %256, %255 ]
%260 = icmp ugt i8* %259, %0
br i1 %260, label %261, label %266
261: ; preds = %258
%262 = getelementptr inbounds i8, i8* %259, i64 -1
%263 = load i8, i8* %262
%264 = tail call i64 @isdigit(i8 signext %263)
%265 = icmp eq i64 %264, 0
br i1 %265, label %266, label %258
266: ; preds = %258, %261
%267 = load i8, i8* %259
%268 = tail call i64 @isdigit(i8 signext %267)
%269 = icmp eq i64 %268, 0
br i1 %269, label %309, label %270
270: ; preds = %266, %270
%271 = phi i32 [ %278, %270 ], [ 0, %266 ]
%272 = phi i8* [ %274, %270 ], [ %259, %266 ]
%273 = mul nsw i32 %271, 10
%274 = getelementptr inbounds i8, i8* %272, i64 1
%275 = load i8, i8* %272
%276 = sext i8 %275 to i32
%277 = add i32 %273, -48
%278 = add i32 %277, %276
%279 = load i8, i8* %274
%280 = tail call i64 @isdigit(i8 signext %279)
%281 = icmp eq i64 %280, 0
br i1 %281, label %309, label %270
282: ; preds = %241, %290
%283 = phi i8* [ %291, %290 ], [ %155, %241 ]
%284 = load i8, i8* %283
switch i8 %284, label %285 [
i8 0, label %292
i8 10, label %292
]
285: ; preds = %282
%286 = tail call i64 @isdigit(i8 signext %284)
%287 = icmp eq i64 %286, 0
br i1 %287, label %290, label %288
288: ; preds = %285
%289 = load i8, i8* %283
br label %292
290: ; preds = %285
%291 = getelementptr inbounds i8, i8* %283, i64 1
br label %282
292: ; preds = %282, %282, %288
%293 = phi i8 [ %289, %288 ], [ %284, %282 ], [ %284, %282 ]
%294 = getelementptr inbounds i8, i8* %283, i64 -1
%295 = tail call i64 @isdigit(i8 signext %293)
%296 = icmp eq i64 %295, 0
br i1 %296, label %309, label %297
297: ; preds = %292, %297
%298 = phi i8* [ %301, %297 ], [ %283, %292 ]
%299 = phi i32 [ %305, %297 ], [ 0, %292 ]
%300 = mul nsw i32 %299, 10
%301 = getelementptr inbounds i8, i8* %298, i64 1
%302 = load i8, i8* %298
%303 = sext i8 %302 to i32
%304 = add i32 %300, -48
%305 = add i32 %304, %303
%306 = load i8, i8* %301
%307 = tail call i64 @isdigit(i8 signext %306)
%308 = icmp eq i64 %307, 0
br i1 %308, label %309, label %297
309: ; preds = %297, %270, %266, %292, %255, %238
%310 = phi i8* [ %155, %238 ], [ %155, %255 ], [ %294, %292 ], [ %155, %266 ], [ %155, %270 ], [ %294, %297 ]
%311 = phi i32 [ %140, %238 ], [ %140, %255 ], [ %140, %292 ], [ %140, %266 ], [ %140, %270 ], [ %305, %297 ]
%312 = phi i32 [ %141, %238 ], [ %141, %255 ], [ %141, %292 ], [ 0, %266 ], [ %278, %270 ], [ %141, %297 ]
%313 = getelementptr inbounds i8, i8* %310, i64 1
br label %138
314: ; preds = %138, %138, %226, %218
%315 = phi i32 [ %195, %218 ], [ %195, %226 ], [ %140, %138 ], [ %140, %138 ]
%316 = phi i32 [ %141, %218 ], [ %234, %226 ], [ %141, %138 ], [ %141, %138 ]
%317 = icmp eq i32 %316, 0
%318 = icmp eq i32 %315, -1
%319 = select i1 %317, i1 true, i1 %318
%320 = icmp sgt i32 %315, %316
%321 = select i1 %319, i1 true, i1 %320
br i1 %321, label %323, label %322
322: ; preds = %314
store i32 %315, i32* %2
store i32 %316, i32* %3
br label %323
323: ; preds = %52, %52, %222, %314, %21, %4, %322
%324 = phi i32 [ 0, %322 ], [ 1, %4 ], [ 1, %21 ], [ 1, %314 ], [ 1, %222 ], [ 1, %52 ], [ 1, %52 ]
ret i32 %324
}