#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 atoi(char *);
scalar_t__ isdigit(char);
void parseFormula(char charFormula[33], int intFormula[10]) {
  char buffer[3];
  int a, i;
  for (a = 0; a < 10; a++) {
    intFormula[a] = 0;
  }
  for (i = 0; i < 33; i++) {
    if (charFormula[i] == 'C') {
      i++;
      if (charFormula[i] == 'l') {
        if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
          intFormula[3] = 1;
        } else {
          buffer[0] = charFormula[i];
          ++i;
          if (isdigit(charFormula[i]) == 0) {
            buffer[1] = '\0';
          } else {
            buffer[1] = charFormula[i];
            buffer[2] = '\0';
          }
          intFormula[3] = atoi(buffer);
        }
      } else if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[0] = 1;
      } else if (charFormula[i] != 'l') {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[0] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'H') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[1] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[1] = atoi(buffer);
      }
      --i;
    } else if ((charFormula[i] == 'B') && (charFormula[++i] == 'r')) {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[2] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[2] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'F') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[4] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[4] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'I') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[5] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[5] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'N') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[6] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[6] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'O') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[7] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[7] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'P') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[8] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[8] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == 'S') {
      ++i;
      if ((isdigit(charFormula[i]) == 0) || (charFormula[i] == '\0')) {
        intFormula[9] = 1;
      } else {
        buffer[0] = charFormula[i];
        ++i;
        if (isdigit(charFormula[i]) == 0) {
          buffer[1] = '\0';
        } else {
          buffer[1] = charFormula[i];
          buffer[2] = '\0';
        }
        intFormula[9] = atoi(buffer);
      }
      --i;
    } else if (charFormula[i] == '\0') {
      break;
    }
  }
}


x86 assembly (clang, -O0):
<parseFormula>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    115e <parseFormula+0x3e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1137 <parseFormula+0x17>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x21,-0x1c(%rbp)
jge    19df <parseFormula+0x8bf>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
jne    1310 <parseFormula+0x1f0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6c,%eax
jne    1246 <parseFormula+0x126>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     11d2 <parseFormula+0xb2>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    11e2 <parseFormula+0xc2>
mov    -0x10(%rbp),%rax
movl   $0x1,0xc(%rax)
jmp    1241 <parseFormula+0x121>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    121d <parseFormula+0xfd>
movb   $0x0,-0x12(%rbp)
jmp    122f <parseFormula+0x10f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0xc(%rax)
jmp    1302 <parseFormula+0x1e2>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1276 <parseFormula+0x156>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1285 <parseFormula+0x165>
mov    -0x10(%rbp),%rax
movl   $0x1,(%rax)
jmp    12fd <parseFormula+0x1dd>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6c,%eax
je     12f8 <parseFormula+0x1d8>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    12d5 <parseFormula+0x1b5>
movb   $0x0,-0x12(%rbp)
jmp    12e7 <parseFormula+0x1c7>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    12fd <parseFormula+0x1dd>
jmp    1302 <parseFormula+0x1e2>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19cc <parseFormula+0x8ac>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x48,%eax
jne    13db <parseFormula+0x2bb>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     135e <parseFormula+0x23e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    136e <parseFormula+0x24e>
mov    -0x10(%rbp),%rax
movl   $0x1,0x4(%rax)
jmp    13cd <parseFormula+0x2ad>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    13a9 <parseFormula+0x289>
movb   $0x0,-0x12(%rbp)
jmp    13bb <parseFormula+0x29b>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19c7 <parseFormula+0x8a7>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x42,%eax
jne    14c3 <parseFormula+0x3a3>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x72,%eax
jne    14c3 <parseFormula+0x3a3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1446 <parseFormula+0x326>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1456 <parseFormula+0x336>
mov    -0x10(%rbp),%rax
movl   $0x1,0x8(%rax)
jmp    14b5 <parseFormula+0x395>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1491 <parseFormula+0x371>
movb   $0x0,-0x12(%rbp)
jmp    14a3 <parseFormula+0x383>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19c2 <parseFormula+0x8a2>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jne    158e <parseFormula+0x46e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1511 <parseFormula+0x3f1>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1521 <parseFormula+0x401>
mov    -0x10(%rbp),%rax
movl   $0x1,0x10(%rax)
jmp    1580 <parseFormula+0x460>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    155c <parseFormula+0x43c>
movb   $0x0,-0x12(%rbp)
jmp    156e <parseFormula+0x44e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19bd <parseFormula+0x89d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x49,%eax
jne    1659 <parseFormula+0x539>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     15dc <parseFormula+0x4bc>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    15ec <parseFormula+0x4cc>
mov    -0x10(%rbp),%rax
movl   $0x1,0x14(%rax)
jmp    164b <parseFormula+0x52b>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1627 <parseFormula+0x507>
movb   $0x0,-0x12(%rbp)
jmp    1639 <parseFormula+0x519>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b8 <parseFormula+0x898>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1724 <parseFormula+0x604>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     16a7 <parseFormula+0x587>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    16b7 <parseFormula+0x597>
mov    -0x10(%rbp),%rax
movl   $0x1,0x18(%rax)
jmp    1716 <parseFormula+0x5f6>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    16f2 <parseFormula+0x5d2>
movb   $0x0,-0x12(%rbp)
jmp    1704 <parseFormula+0x5e4>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19b3 <parseFormula+0x893>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4f,%eax
jne    17ef <parseFormula+0x6cf>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1772 <parseFormula+0x652>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1782 <parseFormula+0x662>
mov    -0x10(%rbp),%rax
movl   $0x1,0x1c(%rax)
jmp    17e1 <parseFormula+0x6c1>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    17bd <parseFormula+0x69d>
movb   $0x0,-0x12(%rbp)
jmp    17cf <parseFormula+0x6af>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19ae <parseFormula+0x88e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
jne    18ba <parseFormula+0x79a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     183d <parseFormula+0x71d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    184d <parseFormula+0x72d>
mov    -0x10(%rbp),%rax
movl   $0x1,0x20(%rax)
jmp    18ac <parseFormula+0x78c>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1888 <parseFormula+0x768>
movb   $0x0,-0x12(%rbp)
jmp    189a <parseFormula+0x77a>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x20(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19a9 <parseFormula+0x889>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x53,%eax
jne    1985 <parseFormula+0x865>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1908 <parseFormula+0x7e8>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1918 <parseFormula+0x7f8>
mov    -0x10(%rbp),%rax
movl   $0x1,0x24(%rax)
jmp    1977 <parseFormula+0x857>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x13(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
jne    1953 <parseFormula+0x833>
movb   $0x0,-0x12(%rbp)
jmp    1965 <parseFormula+0x845>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
lea    -0x13(%rbp),%rdi
call   1040 <atoi@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x24(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    19a4 <parseFormula+0x884>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    199f <parseFormula+0x87f>
jmp    19df <parseFormula+0x8bf>
jmp    19a4 <parseFormula+0x884>
jmp    19a9 <parseFormula+0x889>
jmp    19ae <parseFormula+0x88e>
jmp    19b3 <parseFormula+0x893>
jmp    19b8 <parseFormula+0x898>
jmp    19bd <parseFormula+0x89d>
jmp    19c2 <parseFormula+0x8a2>
jmp    19c7 <parseFormula+0x8a7>
jmp    19cc <parseFormula+0x8ac>
jmp    19d1 <parseFormula+0x8b1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1165 <parseFormula+0x45>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseFormula>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
xorps  %xmm0,%xmm0
movups %xmm0,0x10(%rsi)
movups %xmm0,(%rsi)
movq   $0x0,0x20(%rsi)
xor    %r13d,%r13d
lea    0xeb3(%rip),%r15
nopl   (%rax)
movslq %r13d,%r12
movzbl (%rbx,%r12,1),%eax
cmp    $0x42,%al
je     11f0 <parseFormula+0xd0>
cmp    $0x48,%al
je     1270 <parseFormula+0x150>
cmp    $0x43,%al
jne    130f <parseFormula+0x1ef>
lea    0x1(%r12),%r13
movzbl 0x1(%rbx,%r12,1),%eax
cmp    $0x6c,%al
jne    12da <parseFormula+0x1ba>
mov    $0x6c,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1390 <parseFormula+0x270>
movzbl (%rbx,%r13,1),%eax
test   %al,%al
je     1390 <parseFormula+0x270>
mov    %al,0x5(%rsp)
movsbl 0x2(%rbx,%r12,1),%edi
add    $0x2,%r12
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     11ce <parseFormula+0xae>
movzbl (%rbx,%r12,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %eax,0xc(%r14)
jmp    15e8 <parseFormula+0x4c8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x1(%rbx,%r12,1),%eax
cmp    $0x72,%al
jne    1308 <parseFormula+0x1e8>
lea    0x2(%r12),%r13
movsbl 0x2(%rbx,%r12,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     125f <parseFormula+0x13f>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     125f <parseFormula+0x13f>
mov    %cl,0x5(%rsp)
movsbl 0x3(%rbx,%r12,1),%edi
add    $0x3,%r12
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     124f <parseFormula+0x12f>
movzbl (%rbx,%r12,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %r12d,%r13d
mov    %eax,0x8(%r14)
jmp    15f0 <parseFormula+0x4d0>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%r13
movsbl 0x1(%rbx,%r12,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     12d1 <parseFormula+0x1b1>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     12d1 <parseFormula+0x1b1>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%r12,1),%edi
add    $0x2,%r12
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     12c1 <parseFormula+0x1a1>
movzbl (%rbx,%r12,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %r12d,%r13d
mov    %eax,0x4(%r14)
jmp    15f0 <parseFormula+0x4d0>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12fc <parseFormula+0x1dc>
movzbl (%rbx,%r13,1),%eax
cmp    $0x6c,%al
je     15f0 <parseFormula+0x4d0>
test   %al,%al
jne    15ad <parseFormula+0x48d>
movl   $0x1,(%r14)
jmp    15f0 <parseFormula+0x4d0>
add    $0x1,%r12
mov    %r12d,%r13d
lea    -0x46(%rax),%ecx
cmp    $0xd,%cl
ja     15a7 <parseFormula+0x487>
movzbl %cl,%eax
movslq (%r15,%rax,4),%rax
add    %r15,%rax
jmp    *%rax
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     1387 <parseFormula+0x267>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     1387 <parseFormula+0x267>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     1377 <parseFormula+0x257>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x10(%r14)
jmp    15f0 <parseFormula+0x4d0>
movl   $0x1,0xc(%r14)
jmp    15f0 <parseFormula+0x4d0>
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     13fd <parseFormula+0x2dd>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     13fd <parseFormula+0x2dd>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     13ed <parseFormula+0x2cd>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x14(%r14)
jmp    15f0 <parseFormula+0x4d0>
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     1466 <parseFormula+0x346>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     1466 <parseFormula+0x346>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     1456 <parseFormula+0x336>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x18(%r14)
jmp    15f0 <parseFormula+0x4d0>
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     14cf <parseFormula+0x3af>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     14cf <parseFormula+0x3af>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     14bf <parseFormula+0x39f>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x1c(%r14)
jmp    15f0 <parseFormula+0x4d0>
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     1538 <parseFormula+0x418>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     1538 <parseFormula+0x418>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     1528 <parseFormula+0x408>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x20(%r14)
jmp    15f0 <parseFormula+0x4d0>
movslq %r13d,%rbp
lea    0x1(%rbp),%r13
movsbl 0x1(%rbx,%rbp,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
je     15a1 <parseFormula+0x481>
movzbl (%rbx,%r13,1),%ecx
test   %cl,%cl
je     15a1 <parseFormula+0x481>
mov    %cl,0x5(%rsp)
movsbl 0x2(%rbx,%rbp,1),%edi
add    $0x2,%rbp
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     1591 <parseFormula+0x471>
movzbl (%rbx,%rbp,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %ebp,%r13d
mov    %eax,0x24(%r14)
jmp    15f0 <parseFormula+0x4d0>
test   %al,%al
jne    15f4 <parseFormula+0x4d4>
jmp    1605 <parseFormula+0x4e5>
mov    %al,0x5(%rsp)
movsbl 0x2(%rbx,%r12,1),%edi
add    $0x2,%r12
call   1030 <isdigit@plt>
lea    0x6(%rsp),%rcx
test   %rax,%rax
je     15d8 <parseFormula+0x4b8>
movzbl (%rbx,%r12,1),%eax
mov    %al,0x6(%rsp)
lea    0x7(%rsp),%rcx
movb   $0x0,(%rcx)
lea    0x5(%rsp),%rdi
call   1040 <atoi@plt>
mov    %eax,(%r14)
mov    %r12d,%r13d
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%r13d
lea    0x1(%r13),%eax
cmp    $0x20,%r13d
mov    %eax,%r13d
jl     1150 <parseFormula+0x30>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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