int lexAnalysis(char *str, int len) {
  int i = 0, j;
  char curr, next;
  char t[100] = "";
  char tw[100] = "";
  char tl[100] = "";
loop:
  if (i == len) {
    return 0;
  }
  curr = str[i];
  switch (curr) {
  case '"':
    i++;
    do {
      curr = str[i];
      append(tl, curr);
      i++;
    } while (curr != '"');
    tl[strlen(tl) - 1] = 0;
    printf("<%s, literal>\n", tl);
    memset(tl, 0, 100);
    goto loop;
    break;
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7':
  case '8':
  case '9':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    append(t, curr);
    i++;
    goto loop;
    break;
  case 'a':
  case 'b':
  case 'c':
  case 'd':
  case 'e':
  case 'f':
  case 'g':
  case 'h':
  case 'i':
  case 'j':
  case 'k':
  case 'l':
  case 'm':
  case 'n':
  case 'o':
  case 'p':
  case 'q':
  case 'r':
  case 's':
  case 't':
  case 'u':
  case 'v':
  case 'w':
  case 'x':
  case 'y':
  case 'z':
  case 'A':
  case 'B':
  case 'C':
  case 'D':
  case 'E':
  case 'F':
  case 'G':
  case 'H':
  case 'I':
  case 'J':
  case 'K':
  case 'L':
  case 'M':
  case 'N':
  case 'O':
  case 'P':
  case 'Q':
  case 'R':
  case 'S':
  case 'T':
  case 'U':
  case 'V':
  case 'W':
  case 'X':
  case 'Y':
  case 'Z':
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    if (curr == 'i') {
      i++;
      next = str[i];
      if (next == 'f') {
        if (strlen(tw) > 0) {
          printf("<%s, identifier>\n", tw);
          memset(tw, 0, 100);
        }
        printf("<if, keyword>\n");
        i++;
        goto loop;
      } else if (next == 'n') {
        i++;
        next = str[i];
        if (next == 't') {
          if (strlen(tw) > 0) {
            printf("<%s, identifier>\n", tw);
            memset(tw, 0, 100);
          }
          printf("<int, keyword>\n");
          i++;
          goto loop;
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'e') {
      i++;
      next = str[i];
      if (next == 'l') {
        i++;
        next = str[i];
        if (next == 's') {
          i++;
          next = str[i];
          if (next == 'e') {
            i++;
            next = str[i];
            if (next == ' ') {
              i++;
              next = str[i];
              if (next == 'i') {
                i++;
                next = str[i];
                if (next == 'f') {
                  if (strlen(tw) > 0) {
                    printf("<%s, identifier>\n", tw);
                    memset(tw, 0, 100);
                  }
                  printf("<else if, keyword>\n");
                  i++;
                  goto loop;
                } else {
                  i -= 6;
                }
              } else {
                i -= 5;
              }
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'm') {
      i++;
      next = str[i];
      if (next == 'a') {
        i++;
        next = str[i];
        if (next == 'i') {
          i++;
          next = str[i];
          if (next == 'n') {
            if (strlen(tw) > 0) {
              printf("<%s, identifier>\n", tw);
              memset(tw, 0, 100);
            }
            printf("<main, keyword>\n");
            i++;
            goto loop;
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'l') {
      i++;
      next = str[i];
      if (next == 'o') {
        i++;
        next = str[i];
        if (next == 'n') {
          i++;
          next = str[i];
          if (next == 'g') {
            if (strlen(tw) > 0) {
              printf("<%s, identifier>\n", tw);
              memset(tw, 0, 100);
            }
            printf("<main, keyword>\n");
            i++;
            goto loop;
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'v') {
      i++;
      next = str[i];
      if (next == 'o') {
        i++;
        next = str[i];
        if (next == 'i') {
          i++;
          next = str[i];
          if (next == 'd') {
            if (strlen(tw) > 0) {
              printf("<%s, identifier>\n", tw);
              memset(tw, 0, 100);
            }
            printf("<void, keyword>\n");
            i++;
            goto loop;
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'c') {
      i++;
      next = str[i];
      if (next == 'h') {
        i++;
        next = str[i];
        if (next == 'a') {
          i++;
          next = str[i];
          if (next == 'r') {
            if (strlen(tw) > 0) {
              printf("<%s, identifier>\n", tw);
              memset(tw, 0, 100);
            }
            printf("<char, keyword>\n");
            i++;
            goto loop;
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'w') {
      i++;
      next = str[i];
      if (next == 'h') {
        i++;
        next = str[i];
        if (next == 'i') {
          i++;
          next = str[i];
          if (next == 'l') {
            i++;
            next = str[i];
            if (next == 'e') {
              if (strlen(tw) > 0) {
                printf("<%s, identifier>\n", tw);
                memset(tw, 0, 100);
              }
              printf("<while, keyword>\n");
              i++;
              goto loop;
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'f') {
      i++;
      next = str[i];
      if (next == 'l') {
        i++;
        next = str[i];
        if (next == 'o') {
          i++;
          next = str[i];
          if (next == 'a') {
            i++;
            next = str[i];
            if (next == 't') {
              if (strlen(tw) > 0) {
                printf("<%s, identifier>\n", tw);
                memset(tw, 0, 100);
              }
              printf("<float, keyword>\n");
              i++;
              goto loop;
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 'c') {
      i++;
      next = str[i];
      if (next == 'o') {
        i++;
        next = str[i];
        if (next == 'n') {
          i++;
          next = str[i];
          if (next == 's') {
            i++;
            next = str[i];
            if (next == 't') {
              if (strlen(tw) > 0) {
                printf("<%s, identifier>\n", tw);
                memset(tw, 0, 100);
              }
              printf("<float, keyword>\n");
              i++;
              goto loop;
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 's') {
      i++;
      next = str[i];
      if (next == 'h') {
        i++;
        next = str[i];
        if (next == 'o') {
          i++;
          next = str[i];
          if (next == 'r') {
            i++;
            next = str[i];
            if (next == 't') {
              if (strlen(tw) > 0) {
                printf("<%s, identifier>\n", tw);
                memset(tw, 0, 100);
              }
              printf("<float, keyword>\n");
              i++;
              goto loop;
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    if (curr == 's') {
      i++;
      next = str[i];
      if (next == 't') {
        i++;
        next = str[i];
        if (next == 'r') {
          i++;
          next = str[i];
          if (next == 'u') {
            i++;
            next = str[i];
            if (next == 'c') {
              i++;
              next = str[i];
              if (next == 't') {
                if (strlen(tw) > 0) {
                  printf("<%s, identifier>\n", tw);
                  memset(tw, 0, 100);
                }
                printf("<struct, keyword>\n");
                i++;
                goto loop;
              } else {
                i -= 5;
              }
            } else {
              i -= 4;
            }
          } else {
            i -= 3;
          }
        } else {
          i -= 2;
        }
      } else {
        i--;
      }
    }
    append(tw, curr);
    i++;
    goto loop;
    break;
  case '+':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '+':
      printf("<++, operator>\n");
      i++;
      break;
    case '=':
      printf("<+=, assignment>\n");
      i++;
      break;
    default:
      printf("<+, operator>\n");
    }
    goto loop;
    break;
  case '-':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '-':
      printf("<--, operator>\n");
      i++;
      break;
    case '=':
      printf("<-=, assignment>\n");
      i++;
      break;
    case '>':
      printf("<->, pointer>\n");
      i++;
      break;
    default:
      printf("<-, operator>\n");
    }
    goto loop;
    break;
  case '*':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<*=, assignment>\n");
      i++;
      break;
    default:
      printf("<*, operator>\n");
    }
    goto loop;
    break;
  case '/':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("</=, assignment>\n");
      i++;
      break;
    default:
      printf("</, operator>\n");
    }
    goto loop;
    break;
  case '=':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<==, comparison>\n");
      i++;
      break;
    default:
      printf("<=, assignment>\n");
    }
    goto loop;
    break;
  case '%':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<%%=, assignment>\n");
      i++;
      break;
    default:
      printf("<%%, operator>\n");
    }
    goto loop;
    break;
  case '!':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<!=, relational>\n");
      i++;
      break;
    default:
      printf("<!, logical>\n");
    }
    goto loop;
    break;
  case ' ':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    goto loop;
  case '{':
  case '}':
  case '(':
  case ')':
  case '[':
  case ']':
  case ',':
  case ';':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    printf("<%c, delimiter>\n", curr);
    i++;
    goto loop;
    break;
  case '<':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<<=, relational>\n");
      i++;
      break;
    default:
      printf("<<, relational>\n");
    }
    goto loop;
    break;
  case '>':
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    next = str[i];
    switch (next) {
    case '=':
      printf("<>=, relational>\n");
      i++;
      break;
    default:
      printf("<>, relational>\n");
    }
    goto loop;
    break;
  default:
    if (strlen(tw) > 0) {
      printf("<%s, identifier>\n", tw);
      memset(tw, 0, 100);
    }
    if (strlen(t) > 0) {
      printf("<%s, digit>\n", t);
      memset(t, 0, 100);
    }
    i++;
    goto loop;
  }
}


x86 assembly (clang, -O0):
<lexAnalysis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x160(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    11a6 <lexAnalysis+0x66>
xor    %eax,%eax
add    $0x170,%rsp
pop    %rbp
ret
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x15(%rbp)
movsbl -0x15(%rbp),%eax
add    $0xffffffe0,%eax
mov    %eax,%ecx
mov    %rcx,-0x168(%rbp)
sub    $0x5d,%eax
ja     28b8 <lexAnalysis+0x1778>
mov    -0x168(%rbp),%rax
lea    0x1e25(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x15(%rbp)
lea    -0x160(%rbp),%rdi
movsbl -0x15(%rbp),%esi
mov    $0x0,%al
call   1030 <append@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movsbl -0x15(%rbp),%eax
cmp    $0x22,%eax
jne    11ed <lexAnalysis+0xad>
lea    -0x160(%rbp),%rdi
call   1040 <strlen@plt>
sub    $0x1,%rax
movb   $0x0,-0x160(%rbp,%rax,1)
lea    -0x160(%rbp),%rsi
lea    0x1f2f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x160(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    12a6 <lexAnalysis+0x166>
lea    -0xf0(%rbp),%rsi
lea    0x1efb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
movsbl -0x15(%rbp),%esi
mov    $0x0,%al
call   1030 <append@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    12f8 <lexAnalysis+0x1b8>
lea    -0x80(%rbp),%rsi
lea    0x1eb8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
movsbl -0x15(%rbp),%eax
cmp    $0x69,%eax
jne    142f <lexAnalysis+0x2ef>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x66,%eax
jne    1383 <lexAnalysis+0x243>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1367 <lexAnalysis+0x227>
lea    -0xf0(%rbp),%rsi
lea    0x1e3a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1e38(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
movsbl -0x16(%rbp),%eax
cmp    $0x6e,%eax
jne    141c <lexAnalysis+0x2dc>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    140e <lexAnalysis+0x2ce>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    13f2 <lexAnalysis+0x2b2>
lea    -0xf0(%rbp),%rsi
lea    0x1daf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1dbc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1425 <lexAnalysis+0x2e5>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    142a <lexAnalysis+0x2ea>
jmp    142f <lexAnalysis+0x2ef>
movsbl -0x15(%rbp),%eax
cmp    $0x65,%eax
jne    15c2 <lexAnalysis+0x482>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6c,%eax
jne    15b4 <lexAnalysis+0x474>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x73,%eax
jne    15a6 <lexAnalysis+0x466>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x65,%eax
jne    1598 <lexAnalysis+0x458>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x20,%eax
jne    158a <lexAnalysis+0x44a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x69,%eax
jne    157c <lexAnalysis+0x43c>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x66,%eax
jne    156e <lexAnalysis+0x42e>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1552 <lexAnalysis+0x412>
lea    -0xf0(%rbp),%rsi
lea    0x1c4f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1c6c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x10(%rbp)
jmp    1585 <lexAnalysis+0x445>
mov    -0x10(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x10(%rbp)
jmp    1593 <lexAnalysis+0x453>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    15a1 <lexAnalysis+0x461>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    15af <lexAnalysis+0x46f>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    15bd <lexAnalysis+0x47d>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    15c2 <lexAnalysis+0x482>
movsbl -0x15(%rbp),%eax
cmp    $0x6d,%eax
jne    16bf <lexAnalysis+0x57f>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x61,%eax
jne    16b1 <lexAnalysis+0x571>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x69,%eax
jne    16a3 <lexAnalysis+0x563>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6e,%eax
jne    1695 <lexAnalysis+0x555>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1679 <lexAnalysis+0x539>
lea    -0xf0(%rbp),%rsi
lea    0x1b28(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1b59(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    16ac <lexAnalysis+0x56c>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    16ba <lexAnalysis+0x57a>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    16bf <lexAnalysis+0x57f>
movsbl -0x15(%rbp),%eax
cmp    $0x6c,%eax
jne    17bc <lexAnalysis+0x67c>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6f,%eax
jne    17ae <lexAnalysis+0x66e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6e,%eax
jne    17a0 <lexAnalysis+0x660>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x67,%eax
jne    1792 <lexAnalysis+0x652>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1776 <lexAnalysis+0x636>
lea    -0xf0(%rbp),%rsi
lea    0x1a2b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1a5c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    17a9 <lexAnalysis+0x669>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    17b7 <lexAnalysis+0x677>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    17bc <lexAnalysis+0x67c>
movsbl -0x15(%rbp),%eax
cmp    $0x76,%eax
jne    18b9 <lexAnalysis+0x779>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6f,%eax
jne    18ab <lexAnalysis+0x76b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x69,%eax
jne    189d <lexAnalysis+0x75d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x64,%eax
jne    188f <lexAnalysis+0x74f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1873 <lexAnalysis+0x733>
lea    -0xf0(%rbp),%rsi
lea    0x192e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1970(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    18a6 <lexAnalysis+0x766>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    18b4 <lexAnalysis+0x774>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    18b9 <lexAnalysis+0x779>
movsbl -0x15(%rbp),%eax
cmp    $0x63,%eax
jne    19b6 <lexAnalysis+0x876>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x68,%eax
jne    19a8 <lexAnalysis+0x868>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x61,%eax
jne    199a <lexAnalysis+0x85a>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x72,%eax
jne    198c <lexAnalysis+0x84c>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1970 <lexAnalysis+0x830>
lea    -0xf0(%rbp),%rsi
lea    0x1831(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1884(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    19a3 <lexAnalysis+0x863>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    19b1 <lexAnalysis+0x871>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    19b6 <lexAnalysis+0x876>
movsbl -0x15(%rbp),%eax
cmp    $0x77,%eax
jne    1ae5 <lexAnalysis+0x9a5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x68,%eax
jne    1ad7 <lexAnalysis+0x997>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x69,%eax
jne    1ac9 <lexAnalysis+0x989>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6c,%eax
jne    1abb <lexAnalysis+0x97b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x65,%eax
jne    1aad <lexAnalysis+0x96d>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1a91 <lexAnalysis+0x951>
lea    -0xf0(%rbp),%rsi
lea    0x1710(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1774(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    1ac4 <lexAnalysis+0x984>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    1ad2 <lexAnalysis+0x992>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1ae0 <lexAnalysis+0x9a0>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1ae5 <lexAnalysis+0x9a5>
movsbl -0x15(%rbp),%eax
cmp    $0x66,%eax
jne    1c14 <lexAnalysis+0xad4>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6c,%eax
jne    1c06 <lexAnalysis+0xac6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6f,%eax
jne    1bf8 <lexAnalysis+0xab8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x61,%eax
jne    1bea <lexAnalysis+0xaaa>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    1bdc <lexAnalysis+0xa9c>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1bc0 <lexAnalysis+0xa80>
lea    -0xf0(%rbp),%rsi
lea    0x15e1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1657(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    1bf3 <lexAnalysis+0xab3>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    1c01 <lexAnalysis+0xac1>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1c0f <lexAnalysis+0xacf>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1c14 <lexAnalysis+0xad4>
movsbl -0x15(%rbp),%eax
cmp    $0x63,%eax
jne    1d43 <lexAnalysis+0xc03>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6f,%eax
jne    1d35 <lexAnalysis+0xbf5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6e,%eax
jne    1d27 <lexAnalysis+0xbe7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x73,%eax
jne    1d19 <lexAnalysis+0xbd9>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    1d0b <lexAnalysis+0xbcb>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1cef <lexAnalysis+0xbaf>
lea    -0xf0(%rbp),%rsi
lea    0x14b2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x1528(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    1d22 <lexAnalysis+0xbe2>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    1d30 <lexAnalysis+0xbf0>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1d3e <lexAnalysis+0xbfe>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1d43 <lexAnalysis+0xc03>
movsbl -0x15(%rbp),%eax
cmp    $0x73,%eax
jne    1e72 <lexAnalysis+0xd32>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x68,%eax
jne    1e64 <lexAnalysis+0xd24>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x6f,%eax
jne    1e56 <lexAnalysis+0xd16>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x72,%eax
jne    1e48 <lexAnalysis+0xd08>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    1e3a <lexAnalysis+0xcfa>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1e1e <lexAnalysis+0xcde>
lea    -0xf0(%rbp),%rsi
lea    0x1383(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x13f9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    1e51 <lexAnalysis+0xd11>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    1e5f <lexAnalysis+0xd1f>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1e6d <lexAnalysis+0xd2d>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1e72 <lexAnalysis+0xd32>
movsbl -0x15(%rbp),%eax
cmp    $0x73,%eax
jne    1fd3 <lexAnalysis+0xe93>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    1fc5 <lexAnalysis+0xe85>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x72,%eax
jne    1fb7 <lexAnalysis+0xe77>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x75,%eax
jne    1fa9 <lexAnalysis+0xe69>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x63,%eax
jne    1f9b <lexAnalysis+0xe5b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
cmp    $0x74,%eax
jne    1f8d <lexAnalysis+0xe4d>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    1f71 <lexAnalysis+0xe31>
lea    -0xf0(%rbp),%rsi
lea    0x1230(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    0x12b8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
mov    -0x10(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x10(%rbp)
jmp    1fa4 <lexAnalysis+0xe64>
mov    -0x10(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x10(%rbp)
jmp    1fb2 <lexAnalysis+0xe72>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    1fc0 <lexAnalysis+0xe80>
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
jmp    1fce <lexAnalysis+0xe8e>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1fd3 <lexAnalysis+0xe93>
lea    -0xf0(%rbp),%rdi
movsbl -0x15(%rbp),%esi
mov    $0x0,%al
call   1030 <append@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2031 <lexAnalysis+0xef1>
lea    -0xf0(%rbp),%rsi
lea    0x1170(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2066 <lexAnalysis+0xf26>
lea    -0x80(%rbp),%rsi
lea    0x114a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
mov    %eax,-0x16c(%rbp)
sub    $0x2b,%eax
je     20a9 <lexAnalysis+0xf69>
jmp    2095 <lexAnalysis+0xf55>
mov    -0x16c(%rbp),%eax
sub    $0x3d,%eax
je     20c5 <lexAnalysis+0xf85>
jmp    20e1 <lexAnalysis+0xfa1>
lea    0x1193(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    20ef <lexAnalysis+0xfaf>
lea    0x1187(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    20ef <lexAnalysis+0xfaf>
lea    0x117d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2132 <lexAnalysis+0xff2>
lea    -0xf0(%rbp),%rsi
lea    0x106f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2167 <lexAnalysis+0x1027>
lea    -0x80(%rbp),%rsi
lea    0x1049(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
movsbl -0x16(%rbp),%eax
mov    %eax,-0x170(%rbp)
sub    $0x2d,%eax
je     21be <lexAnalysis+0x107e>
jmp    2196 <lexAnalysis+0x1056>
mov    -0x170(%rbp),%eax
sub    $0x3d,%eax
je     21da <lexAnalysis+0x109a>
jmp    21aa <lexAnalysis+0x106a>
mov    -0x170(%rbp),%eax
sub    $0x3e,%eax
je     21f6 <lexAnalysis+0x10b6>
jmp    2212 <lexAnalysis+0x10d2>
lea    0x10af(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2220 <lexAnalysis+0x10e0>
lea    0x10a3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2220 <lexAnalysis+0x10e0>
lea    0x1099(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2220 <lexAnalysis+0x10e0>
lea    0x108c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2263 <lexAnalysis+0x1123>
lea    -0xf0(%rbp),%rsi
lea    0xf3e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2298 <lexAnalysis+0x1158>
lea    -0x80(%rbp),%rsi
lea    0xf18(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    22db <lexAnalysis+0x119b>
jmp    22bf <lexAnalysis+0x117f>
lea    0xfee(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    22e9 <lexAnalysis+0x11a9>
lea    0xfe4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    232c <lexAnalysis+0x11ec>
lea    -0xf0(%rbp),%rsi
lea    0xe75(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2361 <lexAnalysis+0x1221>
lea    -0x80(%rbp),%rsi
lea    0xe4f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    23a4 <lexAnalysis+0x1264>
jmp    2388 <lexAnalysis+0x1248>
lea    0xf46(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    23b2 <lexAnalysis+0x1272>
lea    0xf3c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    23f5 <lexAnalysis+0x12b5>
lea    -0xf0(%rbp),%rsi
lea    0xdac(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    242a <lexAnalysis+0x12ea>
lea    -0x80(%rbp),%rsi
lea    0xd86(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    246d <lexAnalysis+0x132d>
jmp    2451 <lexAnalysis+0x1311>
lea    0xe9e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    247b <lexAnalysis+0x133b>
lea    0xe94(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    24be <lexAnalysis+0x137e>
lea    -0xf0(%rbp),%rsi
lea    0xce3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    24f3 <lexAnalysis+0x13b3>
lea    -0x80(%rbp),%rsi
lea    0xcbd(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    2536 <lexAnalysis+0x13f6>
jmp    251a <lexAnalysis+0x13da>
lea    0xdf8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    2544 <lexAnalysis+0x1404>
lea    0xdef(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2587 <lexAnalysis+0x1447>
lea    -0xf0(%rbp),%rsi
lea    0xc1a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    25bc <lexAnalysis+0x147c>
lea    -0x80(%rbp),%rsi
lea    0xbf4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    25ff <lexAnalysis+0x14bf>
jmp    25e3 <lexAnalysis+0x14a3>
lea    0xd52(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    260d <lexAnalysis+0x14cd>
lea    0xd48(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2650 <lexAnalysis+0x1510>
lea    -0xf0(%rbp),%rsi
lea    0xb51(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2685 <lexAnalysis+0x1545>
lea    -0x80(%rbp),%rsi
lea    0xb2b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    26d1 <lexAnalysis+0x1591>
lea    -0xf0(%rbp),%rsi
lea    0xad0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2706 <lexAnalysis+0x15c6>
lea    -0x80(%rbp),%rsi
lea    0xaaa(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
movsbl -0x15(%rbp),%esi
lea    0xc4b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2764 <lexAnalysis+0x1624>
lea    -0xf0(%rbp),%rsi
lea    0xa3d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2799 <lexAnalysis+0x1659>
lea    -0x80(%rbp),%rsi
lea    0xa17(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    27dc <lexAnalysis+0x169c>
jmp    27c0 <lexAnalysis+0x1680>
lea    0xba6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    27ea <lexAnalysis+0x16aa>
lea    0xb9c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    282d <lexAnalysis+0x16ed>
lea    -0xf0(%rbp),%rsi
lea    0x974(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    2862 <lexAnalysis+0x1722>
lea    -0x80(%rbp),%rsi
lea    0x94e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
sub    $0x3d,%al
jne    28a5 <lexAnalysis+0x1765>
jmp    2889 <lexAnalysis+0x1749>
lea    0xb00(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    28b3 <lexAnalysis+0x1773>
lea    0xaf6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    118f <lexAnalysis+0x4f>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    28f6 <lexAnalysis+0x17b6>
lea    -0xf0(%rbp),%rsi
lea    0x8ab(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
lea    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x0,%rax
jbe    292b <lexAnalysis+0x17eb>
lea    -0x80(%rbp),%rsi
lea    0x885(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1060 <memset@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    118f <lexAnalysis+0x4f>

x86 assembly (clang, -O2):
<lexAnalysis>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movl   $0x0,0xd0(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
movl   $0x0,0x60(%rsp)
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movl   $0x0,0x140(%rsp)
mov    %esi,0xdc(%rsp)
test   %esi,%esi
je     2074 <lexAnalysis+0xf34>
mov    %rdi,%r15
lea    0x1fe8(%rip),%rbx
lea    0xe0(%rsp),%r14
xor    %r13d,%r13d
jmp    123f <lexAnalysis+0xff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsp,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1030 <append@plt>
add    $0x1,%r13d
cmp    0xdc(%rsp),%r13d
je     2074 <lexAnalysis+0xf34>
movslq %r13d,%rbp
movsbl (%r15,%rbp,1),%r12d
lea    -0x20(%r12),%eax
cmp    $0x5d,%eax
ja     171c <lexAnalysis+0x5dc>
lea    0x1da4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpb   $0x0,0x70(%rsp)
je     12b6 <lexAnalysis+0x176>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
lea    -0x63(%r12),%eax
cmp    $0x14,%al
ja     1220 <lexAnalysis+0xe0>
movzbl %al,%eax
lea    0x1eab(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x1(%rbp,%r15,1),%al
cmp    $0x6f,%al
je     17b5 <lexAnalysis+0x675>
cmp    $0x68,%al
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x61,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x72,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     1342 <lexAnalysis+0x202>
lea    0x1ecb(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x2042(%rip),%rdi
jmp    1693 <lexAnalysis+0x553>
cmpb   $0x0,(%rsp)
je     138d <lexAnalysis+0x24d>
lea    0x1e80(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x70(%rsp),%rdi
jmp    1223 <lexAnalysis+0xe3>
cmpb   $0x0,(%rsp)
je     13d6 <lexAnalysis+0x296>
lea    0x1e37(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1427 <lexAnalysis+0x2e7>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
lea    0x1def(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    122d <lexAnalysis+0xed>
cmpb   $0x6c,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x73,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x65,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x20,0x4(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x69,0x5(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x66,0x6(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     14c4 <lexAnalysis+0x384>
lea    0x1d49(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1ef0(%rip),%rdi
call   1040 <puts@plt>
add    $0x7,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x6c,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x6f,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x61,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
jmp    17cd <lexAnalysis+0x68d>
mov    0x1(%rbp,%r15,1),%al
cmp    $0x6e,%al
je     182d <lexAnalysis+0x6ed>
cmp    $0x66,%al
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     1556 <lexAnalysis+0x416>
lea    0x1cb7(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1e80(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x6f,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x6e,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x67,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
jmp    15ac <lexAnalysis+0x46c>
cmpb   $0x61,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x69,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x6e,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     15eb <lexAnalysis+0x4ab>
lea    0x1c22(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1db9(%rip),%rdi
jmp    1693 <lexAnalysis+0x553>
mov    0x1(%rbp,%r15,1),%al
cmp    $0x74,%al
je     188d <lexAnalysis+0x74d>
cmp    $0x68,%al
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x6f,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x72,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
jmp    17cd <lexAnalysis+0x68d>
cmpb   $0x6f,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x69,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x64,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     168c <lexAnalysis+0x54c>
lea    0x1b81(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1d08(%rip),%rdi
call   1040 <puts@plt>
add    $0x4,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x68,0x1(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x69,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x6c,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x65,0x4(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     1710 <lexAnalysis+0x5d0>
lea    0x1afd(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1c63(%rip),%rdi
jmp    181f <lexAnalysis+0x6df>
cmpb   $0x0,(%rsp)
je     175b <lexAnalysis+0x61b>
lea    0x1ab2(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     122d <lexAnalysis+0xed>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
jmp    122d <lexAnalysis+0xed>
cmpb   $0x6e,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x73,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x74,0x4(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     1818 <lexAnalysis+0x6d8>
lea    0x19f5(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1b4a(%rip),%rdi
call   1040 <puts@plt>
add    $0x5,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x74,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     1878 <lexAnalysis+0x738>
lea    0x1995(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1b4f(%rip),%rdi
call   1040 <puts@plt>
add    $0x3,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x72,0x2(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x75,0x3(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x63,0x4(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x74,0x5(%rbp,%r15,1)
jne    1220 <lexAnalysis+0xe0>
cmpb   $0x0,(%rsp)
je     18fc <lexAnalysis+0x7bc>
lea    0x1911(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
lea    0x1a54(%rip),%rdi
call   1040 <puts@plt>
add    $0x6,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x0,(%rsp)
je     1950 <lexAnalysis+0x810>
lea    0x18bd(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     19a1 <lexAnalysis+0x861>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    1fbd <lexAnalysis+0xe7d>
lea    0x18c9(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
add    $0x1,%r13d
movslq %r13d,%rbx
add    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl (%rbx),%ebp
mov    %r14,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1030 <append@plt>
add    $0x1,%rbx
add    $0x1,%r13d
cmp    $0x22,%ebp
jne    19d0 <lexAnalysis+0x890>
mov    %r14,%rdi
call   1050 <strlen@plt>
movb   $0x0,-0x1(%rax,%r14,1)
lea    0x17cb(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x130(%rsp)
movl   $0x0,0x140(%rsp)
lea    0x179d(%rip),%rbx
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x0,(%rsp)
je     1a94 <lexAnalysis+0x954>
lea    0x1779(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1ae5 <lexAnalysis+0x9a5>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    1fcd <lexAnalysis+0xe8d>
lea    0x1702(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x2,%r13d
jmp    1231 <lexAnalysis+0xf1>
cmpb   $0x0,(%rsp)
je     1b47 <lexAnalysis+0xa07>
lea    0x16c6(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1b98 <lexAnalysis+0xa58>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    1fe7 <lexAnalysis+0xea7>
lea    0x1731(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1bef <lexAnalysis+0xaaf>
lea    0x161e(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1c40 <lexAnalysis+0xb00>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
movsbl 0x1(%r15,%rbp,1),%eax
cmp    $0x3d,%eax
je     2028 <lexAnalysis+0xee8>
cmp    $0x2b,%eax
jne    2031 <lexAnalysis+0xef1>
lea    0x16db(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1ca3 <lexAnalysis+0xb63>
lea    0x156a(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1cf4 <lexAnalysis+0xbb4>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
movsbl 0x1(%r15,%rbp,1),%eax
cmp    $0x3e,%eax
je     203e <lexAnalysis+0xefe>
cmp    $0x3d,%eax
je     2047 <lexAnalysis+0xf07>
cmp    $0x2d,%eax
jne    205c <lexAnalysis+0xf1c>
lea    0x15f0(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1d60 <lexAnalysis+0xc20>
lea    0x14ad(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1db1 <lexAnalysis+0xc71>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    1ff4 <lexAnalysis+0xeb4>
lea    0x14f9(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1e08 <lexAnalysis+0xcc8>
lea    0x1405(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1e59 <lexAnalysis+0xd19>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    2001 <lexAnalysis+0xec1>
lea    0x13f3(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1eb0 <lexAnalysis+0xd70>
lea    0x135d(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1f01 <lexAnalysis+0xdc1>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    200e <lexAnalysis+0xece>
lea    0x138a(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
cmpb   $0x0,(%rsp)
je     1f58 <lexAnalysis+0xe18>
lea    0x12b5(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movl   $0x0,0x60(%rsp)
cmpb   $0x0,0x70(%rsp)
je     1fa9 <lexAnalysis+0xe69>
mov    %rbx,%rdi
lea    0x70(%rsp),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movl   $0x0,0xd0(%rsp)
cmpb   $0x3d,0x1(%r15,%rbp,1)
jne    201b <lexAnalysis+0xedb>
lea    0x1286(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
add    $0x1,%rbp
lea    0x12a8(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
add    $0x1,%rbp
lea    0x1235(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %ebp,%r13d
jmp    1231 <lexAnalysis+0xf1>
add    $0x1,%rbp
lea    0x12dc(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
add    $0x1,%rbp
lea    0x12b0(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
add    $0x1,%rbp
lea    0x1243(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
add    $0x1,%rbp
lea    0x1275(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
add    $0x1,%rbp
lea    0x1208(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
lea    0x12fa(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
add    $0x1,%rbp
lea    0x130d(%rip),%rdi
jmp    2067 <lexAnalysis+0xf27>
lea    0x12a8(%rip),%rdi
jmp    204e <lexAnalysis+0xf0e>
lea    0x12ad(%rip),%rdi
call   1040 <puts@plt>
add    $0x2,%r13d
jmp    1231 <lexAnalysis+0xf1>
add    $0x1,%rbp
lea    0x12b4(%rip),%rdi
call   1040 <puts@plt>
mov    %ebp,%r13d
jmp    1231 <lexAnalysis+0xf1>
xor    %eax,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [15 x i8] c"<%s, literal>\0A\00"
@.str.1 = [18 x i8] c"<%s, identifier>\0A\00"
@.str.2 = [13 x i8] c"<%s, digit>\0A\00"
@.str.3 = [15 x i8] c"<if, keyword>\0A\00"
@.str.4 = [16 x i8] c"<int, keyword>\0A\00"
@.str.5 = [20 x i8] c"<else if, keyword>\0A\00"
@.str.6 = [17 x i8] c"<main, keyword>\0A\00"
@.str.7 = [17 x i8] c"<void, keyword>\0A\00"
@.str.8 = [17 x i8] c"<char, keyword>\0A\00"
@.str.9 = [18 x i8] c"<while, keyword>\0A\00"
@.str.10 = [18 x i8] c"<float, keyword>\0A\00"
@.str.11 = [19 x i8] c"<struct, keyword>\0A\00"
@.str.12 = [16 x i8] c"<++, operator>\0A\00"
@.str.13 = [18 x i8] c"<+=, assignment>\0A\00"
@.str.14 = [15 x i8] c"<+, operator>\0A\00"
@.str.15 = [16 x i8] c"<--, operator>\0A\00"
@.str.16 = [18 x i8] c"<-=, assignment>\0A\00"
@.str.17 = [15 x i8] c"<->, pointer>\0A\00"
@.str.18 = [15 x i8] c"<-, operator>\0A\00"
@.str.19 = [18 x i8] c"<*=, assignment>\0A\00"
@.str.20 = [15 x i8] c"<*, operator>\0A\00"
@.str.21 = [18 x i8] c"</=, assignment>\0A\00"
@.str.22 = [15 x i8] c"</, operator>\0A\00"
@.str.23 = [18 x i8] c"<==, comparison>\0A\00"
@.str.24 = [17 x i8] c"<=, assignment>\0A\00"
@.str.25 = [19 x i8] c"<%%=, assignment>\0A\00"
@.str.26 = [16 x i8] c"<%%, operator>\0A\00"
@.str.27 = [18 x i8] c"<!=, relational>\0A\00"
@.str.28 = [14 x i8] c"<!, logical>\0A\00"
@.str.29 = [17 x i8] c"<%c, delimiter>\0A\00"
@.str.30 = [18 x i8] c"<<=, relational>\0A\00"
@.str.31 = [17 x i8] c"<<, relational>\0A\00"
@.str.32 = [18 x i8] c"<>=, relational>\0A\00"
@.str.33 = [17 x i8] c"<>, relational>\0A\00"
define i32 @lexAnalysis(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8
%8 = alloca i8
%9 = alloca [100 x i8]
%10 = alloca [100 x i8]
%11 = alloca [100 x i8]
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %5
%12 = bitcast [100 x i8]* %9 to i8*
%13 = bitcast [100 x i8]* %10 to i8*
%14 = bitcast [100 x i8]* %11 to i8*
br label %15
15: ; preds = %1259, %1242, %1209, %1171, %1152, %1135, %1102, %1069, %1036, %1003, %970, %929, %886, %862, %775, %699, %623, %547, %475, %414, %353, %292, %219, %128, %101, %63, %47, %2
%16 = load i32, i32* %5
%17 = load i32, i32* %4
%18 = icmp eq i32 %16, %17
br i1 %18, label %19, label %20
19: ; preds = %15
ret i32 0
20: ; preds = %15
%21 = load i8*, i8** %3
%22 = load i32, i32* %5
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i8, i8* %24
store i8 %25, i8* %7
%26 = load i8, i8* %7
%27 = sext i8 %26 to i32
switch i32 %27, label %1243 [
i32 34, label %28
i32 48, label %55
i32 49, label %55
i32 50, label %55
i32 51, label %55
i32 52, label %55
i32 53, label %55
i32 54, label %55
i32 55, label %55
i32 56, label %55
i32 57, label %55
i32 97, label %70
i32 98, label %70
i32 99, label %70
i32 100, label %70
i32 101, label %70
i32 102, label %70
i32 103, label %70
i32 104, label %70
i32 105, label %70
i32 106, label %70
i32 107, label %70
i32 108, label %70
i32 109, label %70
i32 110, label %70
i32 111, label %70
i32 112, label %70
i32 113, label %70
i32 114, label %70
i32 115, label %70
i32 116, label %70
i32 117, label %70
i32 118, label %70
i32 119, label %70
i32 120, label %70
i32 121, label %70
i32 122, label %70
i32 65, label %70
i32 66, label %70
i32 67, label %70
i32 68, label %70
i32 69, label %70
i32 70, label %70
i32 71, label %70
i32 72, label %70
i32 73, label %70
i32 74, label %70
i32 75, label %70
i32 76, label %70
i32 77, label %70
i32 78, label %70
i32 79, label %70
i32 80, label %70
i32 81, label %70
i32 82, label %70
i32 83, label %70
i32 84, label %70
i32 85, label %70
i32 86, label %70
i32 87, label %70
i32 88, label %70
i32 89, label %70
i32 90, label %70
i32 43, label %893
i32 45, label %930
i32 42, label %971
i32 47, label %1004
i32 61, label %1037
i32 37, label %1070
i32 33, label %1103
i32 32, label %1136
i32 123, label %1155
i32 125, label %1155
i32 40, label %1155
i32 41, label %1155
i32 91, label %1155
i32 93, label %1155
i32 44, label %1155
i32 59, label %1155
i32 60, label %1177
i32 62, label %1210
]
28: ; preds = %20
%29 = load i32, i32* %5
%30 = add nsw i32 %29, 1
store i32 %30, i32* %5
br label %31
31: ; preds = %43, %28
%32 = load i8*, i8** %3
%33 = load i32, i32* %5
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %32, i64 %34
%36 = load i8, i8* %35
store i8 %36, i8* %7
%37 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%38 = load i8, i8* %7
%39 = sext i8 %38 to i32
%40 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @append to i32 (i8*, i32, ...)*)(i8* %37, i32 %39)
%41 = load i32, i32* %5
%42 = add nsw i32 %41, 1
store i32 %42, i32* %5
br label %43
43: ; preds = %31
%44 = load i8, i8* %7
%45 = sext i8 %44 to i32
%46 = icmp ne i32 %45, 34
br i1 %46, label %31, label %47
47: ; preds = %43
%48 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%49 = call i64 @strlen(i8* %48)
%50 = sub i64 %49, 1
%51 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 %50
store i8 0, i8* %51
%52 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* %52)
%54 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
br label %15
55: ; preds = %20, %20, %20, %20, %20, %20, %20, %20, %20, %20
%56 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%57 = call i64 @strlen(i8* %56)
%58 = icmp ugt i64 %57, 0
br i1 %58, label %59, label %63
59: ; preds = %55
%60 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %60)
%62 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %63
63: ; preds = %59, %55
%64 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%65 = load i8, i8* %7
%66 = sext i8 %65 to i32
%67 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @append to i32 (i8*, i32, ...)*)(i8* %64, i32 %66)
%68 = load i32, i32* %5
%69 = add nsw i32 %68, 1
store i32 %69, i32* %5
br label %15
70: ; preds = %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20, %20
%71 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%72 = call i64 @strlen(i8* %71)
%73 = icmp ugt i64 %72, 0
br i1 %73, label %74, label %78
74: ; preds = %70
%75 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %75)
%77 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %78
78: ; preds = %74, %70
%79 = load i8, i8* %7
%80 = sext i8 %79 to i32
%81 = icmp eq i32 %80, 105
br i1 %81, label %82, label %141
82: ; preds = %78
%83 = load i32, i32* %5
%84 = add nsw i32 %83, 1
store i32 %84, i32* %5
%85 = load i8*, i8** %3
%86 = load i32, i32* %5
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %85, i64 %87
%89 = load i8, i8* %88
store i8 %89, i8* %8
%90 = load i8, i8* %8
%91 = sext i8 %90 to i32
%92 = icmp eq i32 %91, 102
br i1 %92, label %93, label %105
93: ; preds = %82
%94 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%95 = call i64 @strlen(i8* %94)
%96 = icmp ugt i64 %95, 0
br i1 %96, label %97, label %101
97: ; preds = %93
%98 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %98)
%100 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %101
101: ; preds = %97, %93
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0))
%103 = load i32, i32* %5
%104 = add nsw i32 %103, 1
store i32 %104, i32* %5
br label %15
105: ; preds = %82
%106 = load i8, i8* %8
%107 = sext i8 %106 to i32
%108 = icmp eq i32 %107, 110
br i1 %108, label %109, label %136
109: ; preds = %105
%110 = load i32, i32* %5
%111 = add nsw i32 %110, 1
store i32 %111, i32* %5
%112 = load i8*, i8** %3
%113 = load i32, i32* %5
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = load i8, i8* %115
store i8 %116, i8* %8
%117 = load i8, i8* %8
%118 = sext i8 %117 to i32
%119 = icmp eq i32 %118, 116
br i1 %119, label %120, label %132
120: ; preds = %109
%121 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%122 = call i64 @strlen(i8* %121)
%123 = icmp ugt i64 %122, 0
br i1 %123, label %124, label %128
124: ; preds = %120
%125 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %125)
%127 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %128
128: ; preds = %124, %120
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0))
%130 = load i32, i32* %5
%131 = add nsw i32 %130, 1
store i32 %131, i32* %5
br label %15
132: ; preds = %109
%133 = load i32, i32* %5
%134 = sub nsw i32 %133, 2
store i32 %134, i32* %5
br label %135
135: ; preds = %132
br label %139
136: ; preds = %105
%137 = load i32, i32* %5
%138 = add nsw i32 %137, -1
store i32 %138, i32* %5
br label %139
139: ; preds = %136, %135
br label %140
140: ; preds = %139
br label %141
141: ; preds = %140, %78
%142 = load i8, i8* %7
%143 = sext i8 %142 to i32
%144 = icmp eq i32 %143, 101
br i1 %144, label %145, label %247
145: ; preds = %141
%146 = load i32, i32* %5
%147 = add nsw i32 %146, 1
store i32 %147, i32* %5
%148 = load i8*, i8** %3
%149 = load i32, i32* %5
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %148, i64 %150
%152 = load i8, i8* %151
store i8 %152, i8* %8
%153 = load i8, i8* %8
%154 = sext i8 %153 to i32
%155 = icmp eq i32 %154, 108
br i1 %155, label %156, label %243
156: ; preds = %145
%157 = load i32, i32* %5
%158 = add nsw i32 %157, 1
store i32 %158, i32* %5
%159 = load i8*, i8** %3
%160 = load i32, i32* %5
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8, i8* %159, i64 %161
%163 = load i8, i8* %162
store i8 %163, i8* %8
%164 = load i8, i8* %8
%165 = sext i8 %164 to i32
%166 = icmp eq i32 %165, 115
br i1 %166, label %167, label %239
167: ; preds = %156
%168 = load i32, i32* %5
%169 = add nsw i32 %168, 1
store i32 %169, i32* %5
%170 = load i8*, i8** %3
%171 = load i32, i32* %5
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i8, i8* %170, i64 %172
%174 = load i8, i8* %173
store i8 %174, i8* %8
%175 = load i8, i8* %8
%176 = sext i8 %175 to i32
%177 = icmp eq i32 %176, 101
br i1 %177, label %178, label %235
178: ; preds = %167
%179 = load i32, i32* %5
%180 = add nsw i32 %179, 1
store i32 %180, i32* %5
%181 = load i8*, i8** %3
%182 = load i32, i32* %5
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %181, i64 %183
%185 = load i8, i8* %184
store i8 %185, i8* %8
%186 = load i8, i8* %8
%187 = sext i8 %186 to i32
%188 = icmp eq i32 %187, 32
br i1 %188, label %189, label %231
189: ; preds = %178
%190 = load i32, i32* %5
%191 = add nsw i32 %190, 1
store i32 %191, i32* %5
%192 = load i8*, i8** %3
%193 = load i32, i32* %5
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8, i8* %192, i64 %194
%196 = load i8, i8* %195
store i8 %196, i8* %8
%197 = load i8, i8* %8
%198 = sext i8 %197 to i32
%199 = icmp eq i32 %198, 105
br i1 %199, label %200, label %227
200: ; preds = %189
%201 = load i32, i32* %5
%202 = add nsw i32 %201, 1
store i32 %202, i32* %5
%203 = load i8*, i8** %3
%204 = load i32, i32* %5
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %203, i64 %205
%207 = load i8, i8* %206
store i8 %207, i8* %8
%208 = load i8, i8* %8
%209 = sext i8 %208 to i32
%210 = icmp eq i32 %209, 102
br i1 %210, label %211, label %223
211: ; preds = %200
%212 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%213 = call i64 @strlen(i8* %212)
%214 = icmp ugt i64 %213, 0
br i1 %214, label %215, label %219
215: ; preds = %211
%216 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%217 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %216)
%218 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %219
219: ; preds = %215, %211
%220 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.5, i64 0, i64 0))
%221 = load i32, i32* %5
%222 = add nsw i32 %221, 1
store i32 %222, i32* %5
br label %15
223: ; preds = %200
%224 = load i32, i32* %5
%225 = sub nsw i32 %224, 6
store i32 %225, i32* %5
br label %226
226: ; preds = %223
br label %230
227: ; preds = %189
%228 = load i32, i32* %5
%229 = sub nsw i32 %228, 5
store i32 %229, i32* %5
br label %230
230: ; preds = %227, %226
br label %234
231: ; preds = %178
%232 = load i32, i32* %5
%233 = sub nsw i32 %232, 4
store i32 %233, i32* %5
br label %234
234: ; preds = %231, %230
br label %238
235: ; preds = %167
%236 = load i32, i32* %5
%237 = sub nsw i32 %236, 3
store i32 %237, i32* %5
br label %238
238: ; preds = %235, %234
br label %242
239: ; preds = %156
%240 = load i32, i32* %5
%241 = sub nsw i32 %240, 2
store i32 %241, i32* %5
br label %242
242: ; preds = %239, %238
br label %246
243: ; preds = %145
%244 = load i32, i32* %5
%245 = add nsw i32 %244, -1
store i32 %245, i32* %5
br label %246
246: ; preds = %243, %242
br label %247
247: ; preds = %246, %141
%248 = load i8, i8* %7
%249 = sext i8 %248 to i32
%250 = icmp eq i32 %249, 109
br i1 %250, label %251, label %308
251: ; preds = %247
%252 = load i32, i32* %5
%253 = add nsw i32 %252, 1
store i32 %253, i32* %5
%254 = load i8*, i8** %3
%255 = load i32, i32* %5
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i8, i8* %254, i64 %256
%258 = load i8, i8* %257
store i8 %258, i8* %8
%259 = load i8, i8* %8
%260 = sext i8 %259 to i32
%261 = icmp eq i32 %260, 97
br i1 %261, label %262, label %304
262: ; preds = %251
%263 = load i32, i32* %5
%264 = add nsw i32 %263, 1
store i32 %264, i32* %5
%265 = load i8*, i8** %3
%266 = load i32, i32* %5
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i8, i8* %265, i64 %267
%269 = load i8, i8* %268
store i8 %269, i8* %8
%270 = load i8, i8* %8
%271 = sext i8 %270 to i32
%272 = icmp eq i32 %271, 105
br i1 %272, label %273, label %300
273: ; preds = %262
%274 = load i32, i32* %5
%275 = add nsw i32 %274, 1
store i32 %275, i32* %5
%276 = load i8*, i8** %3
%277 = load i32, i32* %5
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i8, i8* %276, i64 %278
%280 = load i8, i8* %279
store i8 %280, i8* %8
%281 = load i8, i8* %8
%282 = sext i8 %281 to i32
%283 = icmp eq i32 %282, 110
br i1 %283, label %284, label %296
284: ; preds = %273
%285 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%286 = call i64 @strlen(i8* %285)
%287 = icmp ugt i64 %286, 0
br i1 %287, label %288, label %292
288: ; preds = %284
%289 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%290 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %289)
%291 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %292
292: ; preds = %288, %284
%293 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0))
%294 = load i32, i32* %5
%295 = add nsw i32 %294, 1
store i32 %295, i32* %5
br label %15
296: ; preds = %273
%297 = load i32, i32* %5
%298 = sub nsw i32 %297, 3
store i32 %298, i32* %5
br label %299
299: ; preds = %296
br label %303
300: ; preds = %262
%301 = load i32, i32* %5
%302 = sub nsw i32 %301, 2
store i32 %302, i32* %5
br label %303
303: ; preds = %300, %299
br label %307
304: ; preds = %251
%305 = load i32, i32* %5
%306 = add nsw i32 %305, -1
store i32 %306, i32* %5
br label %307
307: ; preds = %304, %303
br label %308
308: ; preds = %307, %247
%309 = load i8, i8* %7
%310 = sext i8 %309 to i32
%311 = icmp eq i32 %310, 108
br i1 %311, label %312, label %369
312: ; preds = %308
%313 = load i32, i32* %5
%314 = add nsw i32 %313, 1
store i32 %314, i32* %5
%315 = load i8*, i8** %3
%316 = load i32, i32* %5
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i8, i8* %315, i64 %317
%319 = load i8, i8* %318
store i8 %319, i8* %8
%320 = load i8, i8* %8
%321 = sext i8 %320 to i32
%322 = icmp eq i32 %321, 111
br i1 %322, label %323, label %365
323: ; preds = %312
%324 = load i32, i32* %5
%325 = add nsw i32 %324, 1
store i32 %325, i32* %5
%326 = load i8*, i8** %3
%327 = load i32, i32* %5
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i8, i8* %326, i64 %328
%330 = load i8, i8* %329
store i8 %330, i8* %8
%331 = load i8, i8* %8
%332 = sext i8 %331 to i32
%333 = icmp eq i32 %332, 110
br i1 %333, label %334, label %361
334: ; preds = %323
%335 = load i32, i32* %5
%336 = add nsw i32 %335, 1
store i32 %336, i32* %5
%337 = load i8*, i8** %3
%338 = load i32, i32* %5
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i8, i8* %337, i64 %339
%341 = load i8, i8* %340
store i8 %341, i8* %8
%342 = load i8, i8* %8
%343 = sext i8 %342 to i32
%344 = icmp eq i32 %343, 103
br i1 %344, label %345, label %357
345: ; preds = %334
%346 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%347 = call i64 @strlen(i8* %346)
%348 = icmp ugt i64 %347, 0
br i1 %348, label %349, label %353
349: ; preds = %345
%350 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%351 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %350)
%352 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %353
353: ; preds = %349, %345
%354 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0))
%355 = load i32, i32* %5
%356 = add nsw i32 %355, 1
store i32 %356, i32* %5
br label %15
357: ; preds = %334
%358 = load i32, i32* %5
%359 = sub nsw i32 %358, 3
store i32 %359, i32* %5
br label %360
360: ; preds = %357
br label %364
361: ; preds = %323
%362 = load i32, i32* %5
%363 = sub nsw i32 %362, 2
store i32 %363, i32* %5
br label %364
364: ; preds = %361, %360
br label %368
365: ; preds = %312
%366 = load i32, i32* %5
%367 = add nsw i32 %366, -1
store i32 %367, i32* %5
br label %368
368: ; preds = %365, %364
br label %369
369: ; preds = %368, %308
%370 = load i8, i8* %7
%371 = sext i8 %370 to i32
%372 = icmp eq i32 %371, 118
br i1 %372, label %373, label %430
373: ; preds = %369
%374 = load i32, i32* %5
%375 = add nsw i32 %374, 1
store i32 %375, i32* %5
%376 = load i8*, i8** %3
%377 = load i32, i32* %5
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds i8, i8* %376, i64 %378
%380 = load i8, i8* %379
store i8 %380, i8* %8
%381 = load i8, i8* %8
%382 = sext i8 %381 to i32
%383 = icmp eq i32 %382, 111
br i1 %383, label %384, label %426
384: ; preds = %373
%385 = load i32, i32* %5
%386 = add nsw i32 %385, 1
store i32 %386, i32* %5
%387 = load i8*, i8** %3
%388 = load i32, i32* %5
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i8, i8* %387, i64 %389
%391 = load i8, i8* %390
store i8 %391, i8* %8
%392 = load i8, i8* %8
%393 = sext i8 %392 to i32
%394 = icmp eq i32 %393, 105
br i1 %394, label %395, label %422
395: ; preds = %384
%396 = load i32, i32* %5
%397 = add nsw i32 %396, 1
store i32 %397, i32* %5
%398 = load i8*, i8** %3
%399 = load i32, i32* %5
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i8, i8* %398, i64 %400
%402 = load i8, i8* %401
store i8 %402, i8* %8
%403 = load i8, i8* %8
%404 = sext i8 %403 to i32
%405 = icmp eq i32 %404, 100
br i1 %405, label %406, label %418
406: ; preds = %395
%407 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%408 = call i64 @strlen(i8* %407)
%409 = icmp ugt i64 %408, 0
br i1 %409, label %410, label %414
410: ; preds = %406
%411 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%412 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %411)
%413 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %414
414: ; preds = %410, %406
%415 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0))
%416 = load i32, i32* %5
%417 = add nsw i32 %416, 1
store i32 %417, i32* %5
br label %15
418: ; preds = %395
%419 = load i32, i32* %5
%420 = sub nsw i32 %419, 3
store i32 %420, i32* %5
br label %421
421: ; preds = %418
br label %425
422: ; preds = %384
%423 = load i32, i32* %5
%424 = sub nsw i32 %423, 2
store i32 %424, i32* %5
br label %425
425: ; preds = %422, %421
br label %429
426: ; preds = %373
%427 = load i32, i32* %5
%428 = add nsw i32 %427, -1
store i32 %428, i32* %5
br label %429
429: ; preds = %426, %425
br label %430
430: ; preds = %429, %369
%431 = load i8, i8* %7
%432 = sext i8 %431 to i32
%433 = icmp eq i32 %432, 99
br i1 %433, label %434, label %491
434: ; preds = %430
%435 = load i32, i32* %5
%436 = add nsw i32 %435, 1
store i32 %436, i32* %5
%437 = load i8*, i8** %3
%438 = load i32, i32* %5
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i8, i8* %437, i64 %439
%441 = load i8, i8* %440
store i8 %441, i8* %8
%442 = load i8, i8* %8
%443 = sext i8 %442 to i32
%444 = icmp eq i32 %443, 104
br i1 %444, label %445, label %487
445: ; preds = %434
%446 = load i32, i32* %5
%447 = add nsw i32 %446, 1
store i32 %447, i32* %5
%448 = load i8*, i8** %3
%449 = load i32, i32* %5
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds i8, i8* %448, i64 %450
%452 = load i8, i8* %451
store i8 %452, i8* %8
%453 = load i8, i8* %8
%454 = sext i8 %453 to i32
%455 = icmp eq i32 %454, 97
br i1 %455, label %456, label %483
456: ; preds = %445
%457 = load i32, i32* %5
%458 = add nsw i32 %457, 1
store i32 %458, i32* %5
%459 = load i8*, i8** %3
%460 = load i32, i32* %5
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i8, i8* %459, i64 %461
%463 = load i8, i8* %462
store i8 %463, i8* %8
%464 = load i8, i8* %8
%465 = sext i8 %464 to i32
%466 = icmp eq i32 %465, 114
br i1 %466, label %467, label %479
467: ; preds = %456
%468 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%469 = call i64 @strlen(i8* %468)
%470 = icmp ugt i64 %469, 0
br i1 %470, label %471, label %475
471: ; preds = %467
%472 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%473 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %472)
%474 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %475
475: ; preds = %471, %467
%476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0))
%477 = load i32, i32* %5
%478 = add nsw i32 %477, 1
store i32 %478, i32* %5
br label %15
479: ; preds = %456
%480 = load i32, i32* %5
%481 = sub nsw i32 %480, 3
store i32 %481, i32* %5
br label %482
482: ; preds = %479
br label %486
483: ; preds = %445
%484 = load i32, i32* %5
%485 = sub nsw i32 %484, 2
store i32 %485, i32* %5
br label %486
486: ; preds = %483, %482
br label %490
487: ; preds = %434
%488 = load i32, i32* %5
%489 = add nsw i32 %488, -1
store i32 %489, i32* %5
br label %490
490: ; preds = %487, %486
br label %491
491: ; preds = %490, %430
%492 = load i8, i8* %7
%493 = sext i8 %492 to i32
%494 = icmp eq i32 %493, 119
br i1 %494, label %495, label %567
495: ; preds = %491
%496 = load i32, i32* %5
%497 = add nsw i32 %496, 1
store i32 %497, i32* %5
%498 = load i8*, i8** %3
%499 = load i32, i32* %5
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i8, i8* %498, i64 %500
%502 = load i8, i8* %501
store i8 %502, i8* %8
%503 = load i8, i8* %8
%504 = sext i8 %503 to i32
%505 = icmp eq i32 %504, 104
br i1 %505, label %506, label %563
506: ; preds = %495
%507 = load i32, i32* %5
%508 = add nsw i32 %507, 1
store i32 %508, i32* %5
%509 = load i8*, i8** %3
%510 = load i32, i32* %5
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds i8, i8* %509, i64 %511
%513 = load i8, i8* %512
store i8 %513, i8* %8
%514 = load i8, i8* %8
%515 = sext i8 %514 to i32
%516 = icmp eq i32 %515, 105
br i1 %516, label %517, label %559
517: ; preds = %506
%518 = load i32, i32* %5
%519 = add nsw i32 %518, 1
store i32 %519, i32* %5
%520 = load i8*, i8** %3
%521 = load i32, i32* %5
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i8, i8* %520, i64 %522
%524 = load i8, i8* %523
store i8 %524, i8* %8
%525 = load i8, i8* %8
%526 = sext i8 %525 to i32
%527 = icmp eq i32 %526, 108
br i1 %527, label %528, label %555
528: ; preds = %517
%529 = load i32, i32* %5
%530 = add nsw i32 %529, 1
store i32 %530, i32* %5
%531 = load i8*, i8** %3
%532 = load i32, i32* %5
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i8, i8* %531, i64 %533
%535 = load i8, i8* %534
store i8 %535, i8* %8
%536 = load i8, i8* %8
%537 = sext i8 %536 to i32
%538 = icmp eq i32 %537, 101
br i1 %538, label %539, label %551
539: ; preds = %528
%540 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%541 = call i64 @strlen(i8* %540)
%542 = icmp ugt i64 %541, 0
br i1 %542, label %543, label %547
543: ; preds = %539
%544 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%545 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %544)
%546 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %547
547: ; preds = %543, %539
%548 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0))
%549 = load i32, i32* %5
%550 = add nsw i32 %549, 1
store i32 %550, i32* %5
br label %15
551: ; preds = %528
%552 = load i32, i32* %5
%553 = sub nsw i32 %552, 4
store i32 %553, i32* %5
br label %554
554: ; preds = %551
br label %558
555: ; preds = %517
%556 = load i32, i32* %5
%557 = sub nsw i32 %556, 3
store i32 %557, i32* %5
br label %558
558: ; preds = %555, %554
br label %562
559: ; preds = %506
%560 = load i32, i32* %5
%561 = sub nsw i32 %560, 2
store i32 %561, i32* %5
br label %562
562: ; preds = %559, %558
br label %566
563: ; preds = %495
%564 = load i32, i32* %5
%565 = add nsw i32 %564, -1
store i32 %565, i32* %5
br label %566
566: ; preds = %563, %562
br label %567
567: ; preds = %566, %491
%568 = load i8, i8* %7
%569 = sext i8 %568 to i32
%570 = icmp eq i32 %569, 102
br i1 %570, label %571, label %643
571: ; preds = %567
%572 = load i32, i32* %5
%573 = add nsw i32 %572, 1
store i32 %573, i32* %5
%574 = load i8*, i8** %3
%575 = load i32, i32* %5
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds i8, i8* %574, i64 %576
%578 = load i8, i8* %577
store i8 %578, i8* %8
%579 = load i8, i8* %8
%580 = sext i8 %579 to i32
%581 = icmp eq i32 %580, 108
br i1 %581, label %582, label %639
582: ; preds = %571
%583 = load i32, i32* %5
%584 = add nsw i32 %583, 1
store i32 %584, i32* %5
%585 = load i8*, i8** %3
%586 = load i32, i32* %5
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i8, i8* %585, i64 %587
%589 = load i8, i8* %588
store i8 %589, i8* %8
%590 = load i8, i8* %8
%591 = sext i8 %590 to i32
%592 = icmp eq i32 %591, 111
br i1 %592, label %593, label %635
593: ; preds = %582
%594 = load i32, i32* %5
%595 = add nsw i32 %594, 1
store i32 %595, i32* %5
%596 = load i8*, i8** %3
%597 = load i32, i32* %5
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds i8, i8* %596, i64 %598
%600 = load i8, i8* %599
store i8 %600, i8* %8
%601 = load i8, i8* %8
%602 = sext i8 %601 to i32
%603 = icmp eq i32 %602, 97
br i1 %603, label %604, label %631
604: ; preds = %593
%605 = load i32, i32* %5
%606 = add nsw i32 %605, 1
store i32 %606, i32* %5
%607 = load i8*, i8** %3
%608 = load i32, i32* %5
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds i8, i8* %607, i64 %609
%611 = load i8, i8* %610
store i8 %611, i8* %8
%612 = load i8, i8* %8
%613 = sext i8 %612 to i32
%614 = icmp eq i32 %613, 116
br i1 %614, label %615, label %627
615: ; preds = %604
%616 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%617 = call i64 @strlen(i8* %616)
%618 = icmp ugt i64 %617, 0
br i1 %618, label %619, label %623
619: ; preds = %615
%620 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%621 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %620)
%622 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %623
623: ; preds = %619, %615
%624 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0))
%625 = load i32, i32* %5
%626 = add nsw i32 %625, 1
store i32 %626, i32* %5
br label %15
627: ; preds = %604
%628 = load i32, i32* %5
%629 = sub nsw i32 %628, 4
store i32 %629, i32* %5
br label %630
630: ; preds = %627
br label %634
631: ; preds = %593
%632 = load i32, i32* %5
%633 = sub nsw i32 %632, 3
store i32 %633, i32* %5
br label %634
634: ; preds = %631, %630
br label %638
635: ; preds = %582
%636 = load i32, i32* %5
%637 = sub nsw i32 %636, 2
store i32 %637, i32* %5
br label %638
638: ; preds = %635, %634
br label %642
639: ; preds = %571
%640 = load i32, i32* %5
%641 = add nsw i32 %640, -1
store i32 %641, i32* %5
br label %642
642: ; preds = %639, %638
br label %643
643: ; preds = %642, %567
%644 = load i8, i8* %7
%645 = sext i8 %644 to i32
%646 = icmp eq i32 %645, 99
br i1 %646, label %647, label %719
647: ; preds = %643
%648 = load i32, i32* %5
%649 = add nsw i32 %648, 1
store i32 %649, i32* %5
%650 = load i8*, i8** %3
%651 = load i32, i32* %5
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds i8, i8* %650, i64 %652
%654 = load i8, i8* %653
store i8 %654, i8* %8
%655 = load i8, i8* %8
%656 = sext i8 %655 to i32
%657 = icmp eq i32 %656, 111
br i1 %657, label %658, label %715
658: ; preds = %647
%659 = load i32, i32* %5
%660 = add nsw i32 %659, 1
store i32 %660, i32* %5
%661 = load i8*, i8** %3
%662 = load i32, i32* %5
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds i8, i8* %661, i64 %663
%665 = load i8, i8* %664
store i8 %665, i8* %8
%666 = load i8, i8* %8
%667 = sext i8 %666 to i32
%668 = icmp eq i32 %667, 110
br i1 %668, label %669, label %711
669: ; preds = %658
%670 = load i32, i32* %5
%671 = add nsw i32 %670, 1
store i32 %671, i32* %5
%672 = load i8*, i8** %3
%673 = load i32, i32* %5
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds i8, i8* %672, i64 %674
%676 = load i8, i8* %675
store i8 %676, i8* %8
%677 = load i8, i8* %8
%678 = sext i8 %677 to i32
%679 = icmp eq i32 %678, 115
br i1 %679, label %680, label %707
680: ; preds = %669
%681 = load i32, i32* %5
%682 = add nsw i32 %681, 1
store i32 %682, i32* %5
%683 = load i8*, i8** %3
%684 = load i32, i32* %5
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds i8, i8* %683, i64 %685
%687 = load i8, i8* %686
store i8 %687, i8* %8
%688 = load i8, i8* %8
%689 = sext i8 %688 to i32
%690 = icmp eq i32 %689, 116
br i1 %690, label %691, label %703
691: ; preds = %680
%692 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%693 = call i64 @strlen(i8* %692)
%694 = icmp ugt i64 %693, 0
br i1 %694, label %695, label %699
695: ; preds = %691
%696 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%697 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %696)
%698 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %699
699: ; preds = %695, %691
%700 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0))
%701 = load i32, i32* %5
%702 = add nsw i32 %701, 1
store i32 %702, i32* %5
br label %15
703: ; preds = %680
%704 = load i32, i32* %5
%705 = sub nsw i32 %704, 4
store i32 %705, i32* %5
br label %706
706: ; preds = %703
br label %710
707: ; preds = %669
%708 = load i32, i32* %5
%709 = sub nsw i32 %708, 3
store i32 %709, i32* %5
br label %710
710: ; preds = %707, %706
br label %714
711: ; preds = %658
%712 = load i32, i32* %5
%713 = sub nsw i32 %712, 2
store i32 %713, i32* %5
br label %714
714: ; preds = %711, %710
br label %718
715: ; preds = %647
%716 = load i32, i32* %5
%717 = add nsw i32 %716, -1
store i32 %717, i32* %5
br label %718
718: ; preds = %715, %714
br label %719
719: ; preds = %718, %643
%720 = load i8, i8* %7
%721 = sext i8 %720 to i32
%722 = icmp eq i32 %721, 115
br i1 %722, label %723, label %795
723: ; preds = %719
%724 = load i32, i32* %5
%725 = add nsw i32 %724, 1
store i32 %725, i32* %5
%726 = load i8*, i8** %3
%727 = load i32, i32* %5
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i8, i8* %726, i64 %728
%730 = load i8, i8* %729
store i8 %730, i8* %8
%731 = load i8, i8* %8
%732 = sext i8 %731 to i32
%733 = icmp eq i32 %732, 104
br i1 %733, label %734, label %791
734: ; preds = %723
%735 = load i32, i32* %5
%736 = add nsw i32 %735, 1
store i32 %736, i32* %5
%737 = load i8*, i8** %3
%738 = load i32, i32* %5
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds i8, i8* %737, i64 %739
%741 = load i8, i8* %740
store i8 %741, i8* %8
%742 = load i8, i8* %8
%743 = sext i8 %742 to i32
%744 = icmp eq i32 %743, 111
br i1 %744, label %745, label %787
745: ; preds = %734
%746 = load i32, i32* %5
%747 = add nsw i32 %746, 1
store i32 %747, i32* %5
%748 = load i8*, i8** %3
%749 = load i32, i32* %5
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds i8, i8* %748, i64 %750
%752 = load i8, i8* %751
store i8 %752, i8* %8
%753 = load i8, i8* %8
%754 = sext i8 %753 to i32
%755 = icmp eq i32 %754, 114
br i1 %755, label %756, label %783
756: ; preds = %745
%757 = load i32, i32* %5
%758 = add nsw i32 %757, 1
store i32 %758, i32* %5
%759 = load i8*, i8** %3
%760 = load i32, i32* %5
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds i8, i8* %759, i64 %761
%763 = load i8, i8* %762
store i8 %763, i8* %8
%764 = load i8, i8* %8
%765 = sext i8 %764 to i32
%766 = icmp eq i32 %765, 116
br i1 %766, label %767, label %779
767: ; preds = %756
%768 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%769 = call i64 @strlen(i8* %768)
%770 = icmp ugt i64 %769, 0
br i1 %770, label %771, label %775
771: ; preds = %767
%772 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%773 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %772)
%774 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %775
775: ; preds = %771, %767
%776 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0))
%777 = load i32, i32* %5
%778 = add nsw i32 %777, 1
store i32 %778, i32* %5
br label %15
779: ; preds = %756
%780 = load i32, i32* %5
%781 = sub nsw i32 %780, 4
store i32 %781, i32* %5
br label %782
782: ; preds = %779
br label %786
783: ; preds = %745
%784 = load i32, i32* %5
%785 = sub nsw i32 %784, 3
store i32 %785, i32* %5
br label %786
786: ; preds = %783, %782
br label %790
787: ; preds = %734
%788 = load i32, i32* %5
%789 = sub nsw i32 %788, 2
store i32 %789, i32* %5
br label %790
790: ; preds = %787, %786
br label %794
791: ; preds = %723
%792 = load i32, i32* %5
%793 = add nsw i32 %792, -1
store i32 %793, i32* %5
br label %794
794: ; preds = %791, %790
br label %795
795: ; preds = %794, %719
%796 = load i8, i8* %7
%797 = sext i8 %796 to i32
%798 = icmp eq i32 %797, 115
br i1 %798, label %799, label %886
799: ; preds = %795
%800 = load i32, i32* %5
%801 = add nsw i32 %800, 1
store i32 %801, i32* %5
%802 = load i8*, i8** %3
%803 = load i32, i32* %5
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds i8, i8* %802, i64 %804
%806 = load i8, i8* %805
store i8 %806, i8* %8
%807 = load i8, i8* %8
%808 = sext i8 %807 to i32
%809 = icmp eq i32 %808, 116
br i1 %809, label %810, label %882
810: ; preds = %799
%811 = load i32, i32* %5
%812 = add nsw i32 %811, 1
store i32 %812, i32* %5
%813 = load i8*, i8** %3
%814 = load i32, i32* %5
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds i8, i8* %813, i64 %815
%817 = load i8, i8* %816
store i8 %817, i8* %8
%818 = load i8, i8* %8
%819 = sext i8 %818 to i32
%820 = icmp eq i32 %819, 114
br i1 %820, label %821, label %878
821: ; preds = %810
%822 = load i32, i32* %5
%823 = add nsw i32 %822, 1
store i32 %823, i32* %5
%824 = load i8*, i8** %3
%825 = load i32, i32* %5
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds i8, i8* %824, i64 %826
%828 = load i8, i8* %827
store i8 %828, i8* %8
%829 = load i8, i8* %8
%830 = sext i8 %829 to i32
%831 = icmp eq i32 %830, 117
br i1 %831, label %832, label %874
832: ; preds = %821
%833 = load i32, i32* %5
%834 = add nsw i32 %833, 1
store i32 %834, i32* %5
%835 = load i8*, i8** %3
%836 = load i32, i32* %5
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds i8, i8* %835, i64 %837
%839 = load i8, i8* %838
store i8 %839, i8* %8
%840 = load i8, i8* %8
%841 = sext i8 %840 to i32
%842 = icmp eq i32 %841, 99
br i1 %842, label %843, label %870
843: ; preds = %832
%844 = load i32, i32* %5
%845 = add nsw i32 %844, 1
store i32 %845, i32* %5
%846 = load i8*, i8** %3
%847 = load i32, i32* %5
%848 = sext i32 %847 to i64
%849 = getelementptr inbounds i8, i8* %846, i64 %848
%850 = load i8, i8* %849
store i8 %850, i8* %8
%851 = load i8, i8* %8
%852 = sext i8 %851 to i32
%853 = icmp eq i32 %852, 116
br i1 %853, label %854, label %866
854: ; preds = %843
%855 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%856 = call i64 @strlen(i8* %855)
%857 = icmp ugt i64 %856, 0
br i1 %857, label %858, label %862
858: ; preds = %854
%859 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%860 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %859)
%861 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %862
862: ; preds = %858, %854
%863 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.11, i64 0, i64 0))
%864 = load i32, i32* %5
%865 = add nsw i32 %864, 1
store i32 %865, i32* %5
br label %15
866: ; preds = %843
%867 = load i32, i32* %5
%868 = sub nsw i32 %867, 5
store i32 %868, i32* %5
br label %869
869: ; preds = %866
br label %873
870: ; preds = %832
%871 = load i32, i32* %5
%872 = sub nsw i32 %871, 4
store i32 %872, i32* %5
br label %873
873: ; preds = %870, %869
br label %877
874: ; preds = %821
%875 = load i32, i32* %5
%876 = sub nsw i32 %875, 3
store i32 %876, i32* %5
br label %877
877: ; preds = %874, %873
br label %881
878: ; preds = %810
%879 = load i32, i32* %5
%880 = sub nsw i32 %879, 2
store i32 %880, i32* %5
br label %881
881: ; preds = %878, %877
br label %885
882: ; preds = %799
%883 = load i32, i32* %5
%884 = add nsw i32 %883, -1
store i32 %884, i32* %5
br label %885
885: ; preds = %882, %881
br label %886
886: ; preds = %885, %795
%887 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%888 = load i8, i8* %7
%889 = sext i8 %888 to i32
%890 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @append to i32 (i8*, i32, ...)*)(i8* %887, i32 %889)
%891 = load i32, i32* %5
%892 = add nsw i32 %891, 1
store i32 %892, i32* %5
br label %15
893: ; preds = %20
%894 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%895 = call i64 @strlen(i8* %894)
%896 = icmp ugt i64 %895, 0
br i1 %896, label %897, label %901
897: ; preds = %893
%898 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%899 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %898)
%900 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %901
901: ; preds = %897, %893
%902 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%903 = call i64 @strlen(i8* %902)
%904 = icmp ugt i64 %903, 0
br i1 %904, label %905, label %909
905: ; preds = %901
%906 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%907 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %906)
%908 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %909
909: ; preds = %905, %901
%910 = load i32, i32* %5
%911 = add nsw i32 %910, 1
store i32 %911, i32* %5
%912 = load i8*, i8** %3
%913 = load i32, i32* %5
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds i8, i8* %912, i64 %914
%916 = load i8, i8* %915
store i8 %916, i8* %8
%917 = load i8, i8* %8
%918 = sext i8 %917 to i32
switch i32 %918, label %927 [
i32 43, label %919
i32 61, label %923
]
919: ; preds = %909
%920 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.12, i64 0, i64 0))
%921 = load i32, i32* %5
%922 = add nsw i32 %921, 1
store i32 %922, i32* %5
br label %929
923: ; preds = %909
%924 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0))
%925 = load i32, i32* %5
%926 = add nsw i32 %925, 1
store i32 %926, i32* %5
br label %929
927: ; preds = %909
%928 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.14, i64 0, i64 0))
br label %929
929: ; preds = %927, %923, %919
br label %15
930: ; preds = %20
%931 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%932 = call i64 @strlen(i8* %931)
%933 = icmp ugt i64 %932, 0
br i1 %933, label %934, label %938
934: ; preds = %930
%935 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%936 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %935)
%937 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %938
938: ; preds = %934, %930
%939 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%940 = call i64 @strlen(i8* %939)
%941 = icmp ugt i64 %940, 0
br i1 %941, label %942, label %946
942: ; preds = %938
%943 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%944 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %943)
%945 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %946
946: ; preds = %942, %938
%947 = load i32, i32* %5
%948 = add nsw i32 %947, 1
store i32 %948, i32* %5
%949 = load i8*, i8** %3
%950 = load i32, i32* %5
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds i8, i8* %949, i64 %951
%953 = load i8, i8* %952
store i8 %953, i8* %8
%954 = load i8, i8* %8
%955 = sext i8 %954 to i32
switch i32 %955, label %968 [
i32 45, label %956
i32 61, label %960
i32 62, label %964
]
956: ; preds = %946
%957 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.15, i64 0, i64 0))
%958 = load i32, i32* %5
%959 = add nsw i32 %958, 1
store i32 %959, i32* %5
br label %970
960: ; preds = %946
%961 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.16, i64 0, i64 0))
%962 = load i32, i32* %5
%963 = add nsw i32 %962, 1
store i32 %963, i32* %5
br label %970
964: ; preds = %946
%965 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.17, i64 0, i64 0))
%966 = load i32, i32* %5
%967 = add nsw i32 %966, 1
store i32 %967, i32* %5
br label %970
968: ; preds = %946
%969 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.18, i64 0, i64 0))
br label %970
970: ; preds = %968, %964, %960, %956
br label %15
971: ; preds = %20
%972 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%973 = call i64 @strlen(i8* %972)
%974 = icmp ugt i64 %973, 0
br i1 %974, label %975, label %979
975: ; preds = %971
%976 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%977 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %976)
%978 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %979
979: ; preds = %975, %971
%980 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%981 = call i64 @strlen(i8* %980)
%982 = icmp ugt i64 %981, 0
br i1 %982, label %983, label %987
983: ; preds = %979
%984 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%985 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %984)
%986 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %987
987: ; preds = %983, %979
%988 = load i32, i32* %5
%989 = add nsw i32 %988, 1
store i32 %989, i32* %5
%990 = load i8*, i8** %3
%991 = load i32, i32* %5
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds i8, i8* %990, i64 %992
%994 = load i8, i8* %993
store i8 %994, i8* %8
%995 = load i8, i8* %8
%996 = sext i8 %995 to i32
switch i32 %996, label %1001 [
i32 61, label %997
]
997: ; preds = %987
%998 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.19, i64 0, i64 0))
%999 = load i32, i32* %5
%1000 = add nsw i32 %999, 1
store i32 %1000, i32* %5
br label %1003
1001: ; preds = %987
%1002 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.20, i64 0, i64 0))
br label %1003
1003: ; preds = %1001, %997
br label %15
1004: ; preds = %20
%1005 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1006 = call i64 @strlen(i8* %1005)
%1007 = icmp ugt i64 %1006, 0
br i1 %1007, label %1008, label %1012
1008: ; preds = %1004
%1009 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1010 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1009)
%1011 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1012
1012: ; preds = %1008, %1004
%1013 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1014 = call i64 @strlen(i8* %1013)
%1015 = icmp ugt i64 %1014, 0
br i1 %1015, label %1016, label %1020
1016: ; preds = %1012
%1017 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1018 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1017)
%1019 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1020
1020: ; preds = %1016, %1012
%1021 = load i32, i32* %5
%1022 = add nsw i32 %1021, 1
store i32 %1022, i32* %5
%1023 = load i8*, i8** %3
%1024 = load i32, i32* %5
%1025 = sext i32 %1024 to i64
%1026 = getelementptr inbounds i8, i8* %1023, i64 %1025
%1027 = load i8, i8* %1026
store i8 %1027, i8* %8
%1028 = load i8, i8* %8
%1029 = sext i8 %1028 to i32
switch i32 %1029, label %1034 [
i32 61, label %1030
]
1030: ; preds = %1020
%1031 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.21, i64 0, i64 0))
%1032 = load i32, i32* %5
%1033 = add nsw i32 %1032, 1
store i32 %1033, i32* %5
br label %1036
1034: ; preds = %1020
%1035 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.22, i64 0, i64 0))
br label %1036
1036: ; preds = %1034, %1030
br label %15
1037: ; preds = %20
%1038 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1039 = call i64 @strlen(i8* %1038)
%1040 = icmp ugt i64 %1039, 0
br i1 %1040, label %1041, label %1045
1041: ; preds = %1037
%1042 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1043 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1042)
%1044 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1045
1045: ; preds = %1041, %1037
%1046 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1047 = call i64 @strlen(i8* %1046)
%1048 = icmp ugt i64 %1047, 0
br i1 %1048, label %1049, label %1053
1049: ; preds = %1045
%1050 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1051 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1050)
%1052 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1053
1053: ; preds = %1049, %1045
%1054 = load i32, i32* %5
%1055 = add nsw i32 %1054, 1
store i32 %1055, i32* %5
%1056 = load i8*, i8** %3
%1057 = load i32, i32* %5
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds i8, i8* %1056, i64 %1058
%1060 = load i8, i8* %1059
store i8 %1060, i8* %8
%1061 = load i8, i8* %8
%1062 = sext i8 %1061 to i32
switch i32 %1062, label %1067 [
i32 61, label %1063
]
1063: ; preds = %1053
%1064 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.23, i64 0, i64 0))
%1065 = load i32, i32* %5
%1066 = add nsw i32 %1065, 1
store i32 %1066, i32* %5
br label %1069
1067: ; preds = %1053
%1068 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.24, i64 0, i64 0))
br label %1069
1069: ; preds = %1067, %1063
br label %15
1070: ; preds = %20
%1071 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1072 = call i64 @strlen(i8* %1071)
%1073 = icmp ugt i64 %1072, 0
br i1 %1073, label %1074, label %1078
1074: ; preds = %1070
%1075 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1076 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1075)
%1077 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1078
1078: ; preds = %1074, %1070
%1079 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1080 = call i64 @strlen(i8* %1079)
%1081 = icmp ugt i64 %1080, 0
br i1 %1081, label %1082, label %1086
1082: ; preds = %1078
%1083 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1084 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1083)
%1085 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1086
1086: ; preds = %1082, %1078
%1087 = load i32, i32* %5
%1088 = add nsw i32 %1087, 1
store i32 %1088, i32* %5
%1089 = load i8*, i8** %3
%1090 = load i32, i32* %5
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds i8, i8* %1089, i64 %1091
%1093 = load i8, i8* %1092
store i8 %1093, i8* %8
%1094 = load i8, i8* %8
%1095 = sext i8 %1094 to i32
switch i32 %1095, label %1100 [
i32 61, label %1096
]
1096: ; preds = %1086
%1097 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.25, i64 0, i64 0))
%1098 = load i32, i32* %5
%1099 = add nsw i32 %1098, 1
store i32 %1099, i32* %5
br label %1102
1100: ; preds = %1086
%1101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.26, i64 0, i64 0))
br label %1102
1102: ; preds = %1100, %1096
br label %15
1103: ; preds = %20
%1104 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1105 = call i64 @strlen(i8* %1104)
%1106 = icmp ugt i64 %1105, 0
br i1 %1106, label %1107, label %1111
1107: ; preds = %1103
%1108 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1108)
%1110 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1111
1111: ; preds = %1107, %1103
%1112 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1113 = call i64 @strlen(i8* %1112)
%1114 = icmp ugt i64 %1113, 0
br i1 %1114, label %1115, label %1119
1115: ; preds = %1111
%1116 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1116)
%1118 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1119
1119: ; preds = %1115, %1111
%1120 = load i32, i32* %5
%1121 = add nsw i32 %1120, 1
store i32 %1121, i32* %5
%1122 = load i8*, i8** %3
%1123 = load i32, i32* %5
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds i8, i8* %1122, i64 %1124
%1126 = load i8, i8* %1125
store i8 %1126, i8* %8
%1127 = load i8, i8* %8
%1128 = sext i8 %1127 to i32
switch i32 %1128, label %1133 [
i32 61, label %1129
]
1129: ; preds = %1119
%1130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.27, i64 0, i64 0))
%1131 = load i32, i32* %5
%1132 = add nsw i32 %1131, 1
store i32 %1132, i32* %5
br label %1135
1133: ; preds = %1119
%1134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.28, i64 0, i64 0))
br label %1135
1135: ; preds = %1133, %1129
br label %15
1136: ; preds = %20
%1137 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1138 = call i64 @strlen(i8* %1137)
%1139 = icmp ugt i64 %1138, 0
br i1 %1139, label %1140, label %1144
1140: ; preds = %1136
%1141 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1141)
%1143 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1144
1144: ; preds = %1140, %1136
%1145 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1146 = call i64 @strlen(i8* %1145)
%1147 = icmp ugt i64 %1146, 0
br i1 %1147, label %1148, label %1152
1148: ; preds = %1144
%1149 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1149)
%1151 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1152
1152: ; preds = %1148, %1144
%1153 = load i32, i32* %5
%1154 = add nsw i32 %1153, 1
store i32 %1154, i32* %5
br label %15
1155: ; preds = %20, %20, %20, %20, %20, %20, %20, %20
%1156 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1157 = call i64 @strlen(i8* %1156)
%1158 = icmp ugt i64 %1157, 0
br i1 %1158, label %1159, label %1163
1159: ; preds = %1155
%1160 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1161 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1160)
%1162 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1163
1163: ; preds = %1159, %1155
%1164 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1165 = call i64 @strlen(i8* %1164)
%1166 = icmp ugt i64 %1165, 0
br i1 %1166, label %1167, label %1171
1167: ; preds = %1163
%1168 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1168)
%1170 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1171
1171: ; preds = %1167, %1163
%1172 = load i8, i8* %7
%1173 = sext i8 %1172 to i32
%1174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.29, i64 0, i64 0), i32 %1173)
%1175 = load i32, i32* %5
%1176 = add nsw i32 %1175, 1
store i32 %1176, i32* %5
br label %15
1177: ; preds = %20
%1178 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1179 = call i64 @strlen(i8* %1178)
%1180 = icmp ugt i64 %1179, 0
br i1 %1180, label %1181, label %1185
1181: ; preds = %1177
%1182 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1183 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1182)
%1184 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1185
1185: ; preds = %1181, %1177
%1186 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1187 = call i64 @strlen(i8* %1186)
%1188 = icmp ugt i64 %1187, 0
br i1 %1188, label %1189, label %1193
1189: ; preds = %1185
%1190 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1190)
%1192 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1193
1193: ; preds = %1189, %1185
%1194 = load i32, i32* %5
%1195 = add nsw i32 %1194, 1
store i32 %1195, i32* %5
%1196 = load i8*, i8** %3
%1197 = load i32, i32* %5
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds i8, i8* %1196, i64 %1198
%1200 = load i8, i8* %1199
store i8 %1200, i8* %8
%1201 = load i8, i8* %8
%1202 = sext i8 %1201 to i32
switch i32 %1202, label %1207 [
i32 61, label %1203
]
1203: ; preds = %1193
%1204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.30, i64 0, i64 0))
%1205 = load i32, i32* %5
%1206 = add nsw i32 %1205, 1
store i32 %1206, i32* %5
br label %1209
1207: ; preds = %1193
%1208 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i64 0, i64 0))
br label %1209
1209: ; preds = %1207, %1203
br label %15
1210: ; preds = %20
%1211 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1212 = call i64 @strlen(i8* %1211)
%1213 = icmp ugt i64 %1212, 0
br i1 %1213, label %1214, label %1218
1214: ; preds = %1210
%1215 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1216 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1215)
%1217 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1218
1218: ; preds = %1214, %1210
%1219 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1220 = call i64 @strlen(i8* %1219)
%1221 = icmp ugt i64 %1220, 0
br i1 %1221, label %1222, label %1226
1222: ; preds = %1218
%1223 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1224 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1223)
%1225 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1226
1226: ; preds = %1222, %1218
%1227 = load i32, i32* %5
%1228 = add nsw i32 %1227, 1
store i32 %1228, i32* %5
%1229 = load i8*, i8** %3
%1230 = load i32, i32* %5
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds i8, i8* %1229, i64 %1231
%1233 = load i8, i8* %1232
store i8 %1233, i8* %8
%1234 = load i8, i8* %8
%1235 = sext i8 %1234 to i32
switch i32 %1235, label %1240 [
i32 61, label %1236
]
1236: ; preds = %1226
%1237 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.32, i64 0, i64 0))
%1238 = load i32, i32* %5
%1239 = add nsw i32 %1238, 1
store i32 %1239, i32* %5
br label %1242
1240: ; preds = %1226
%1241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.33, i64 0, i64 0))
br label %1242
1242: ; preds = %1240, %1236
br label %15
1243: ; preds = %20
%1244 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1245 = call i64 @strlen(i8* %1244)
%1246 = icmp ugt i64 %1245, 0
br i1 %1246, label %1247, label %1251
1247: ; preds = %1243
%1248 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
%1249 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %1248)
%1250 = getelementptr inbounds [100 x i8], [100 x i8]* %10, i64 0, i64 0
br label %1251
1251: ; preds = %1247, %1243
%1252 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1253 = call i64 @strlen(i8* %1252)
%1254 = icmp ugt i64 %1253, 0
br i1 %1254, label %1255, label %1259
1255: ; preds = %1251
%1256 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
%1257 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* %1256)
%1258 = getelementptr inbounds [100 x i8], [100 x i8]* %9, i64 0, i64 0
br label %1259
1259: ; preds = %1255, %1251
%1260 = load i32, i32* %5
%1261 = add nsw i32 %1260, 1
store i32 %1261, i32* %5
br label %15
}

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