void state_machine(const char *map, const char *end) {
  const char *next = map;
  const char *map_dot;
  unsigned long __buf = 0;
  for (;;) {
  start : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
  __start:
    if (((unsigned char)__buf) >
        ((('/') > ((('\'') > ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                   ? ('"')
                                   : ((('#') > ('C') ? ('#') : ('C')))))
                        ? ('\'')
                        : ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                ? ('"')
                                : ((('#') > ('C') ? ('#') : ('C')))))))
              ? ('/')
              : ((('\'') > ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                 ? ('"')
                                 : ((('#') > ('C') ? ('#') : ('C')))))
                      ? ('\'')
                      : ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                              ? ('"')
                              : ((('#') > ('C') ? ('#') : ('C'))))))))))
      goto start;
    if (((unsigned char)__buf) <
        ((('/') < ((('\'') < ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                   ? ('"')
                                   : ((('#') < ('C') ? ('#') : ('C')))))
                        ? ('\'')
                        : ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                ? ('"')
                                : ((('#') < ('C') ? ('#') : ('C')))))))
              ? ('/')
              : ((('\'') < ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                 ? ('"')
                                 : ((('#') < ('C') ? ('#') : ('C')))))
                      ? ('\'')
                      : ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                              ? ('"')
                              : ((('#') < ('C') ? ('#') : ('C'))))))))))
      goto start;
    if (((unsigned char)__buf) == '/')
      goto slash;
    if (((unsigned char)__buf) == '\'')
      goto squote;
    if (((unsigned char)__buf) == '"')
      goto dquote;
    if (((unsigned char)__buf) == '#')
      goto pound;
    if (((unsigned char)__buf) == 'C')
      goto cee;
    goto start;
  slash_slash : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '\n')
      goto start;
    if (((unsigned char)__buf) != '\\')
      goto slash_slash;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    goto slash_slash;
  slash : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '/')
      goto slash_slash;
    if (((unsigned char)__buf) != '*')
      goto __start;
  slash_star_dot_star : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
  __slash_star_dot_star:
    if (((unsigned char)__buf) != '*')
      goto slash_star_dot_star;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != '/')
      goto __slash_star_dot_star;
    goto start;
  squote : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '\'')
      goto start;
    if (((unsigned char)__buf) != '\\')
      goto squote;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    goto squote;
  dquote : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '"')
      goto start;
    if (((unsigned char)__buf) != '\\')
      goto dquote;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    goto dquote;
  pound : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == ' ')
      goto pound;
    if (((unsigned char)__buf) == '\t')
      goto pound;
    if (((unsigned char)__buf) == 'i')
      goto pound_i;
    if (((unsigned char)__buf) == 'd')
      goto pound_d;
    if (((unsigned char)__buf) == 'u')
      goto pound_u;
    goto __start;
  pound_i : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) != 'n')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'c')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'l')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'u')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'd')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'e')
      goto __start;
    goto pound_include;
  pound_include : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == ' ')
      goto pound_include;
    if (((unsigned char)__buf) == '\t')
      goto pound_include;
    map_dot = next;
    if (((unsigned char)__buf) == '"')
      goto pound_include_dquote;
    if (((unsigned char)__buf) == '<')
      goto pound_include_langle;
    goto __start;
  pound_include_dquote : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '\n')
      goto start;
    if (((unsigned char)__buf) != '"')
      goto pound_include_dquote;
    handle_include(0, map_dot, next - map_dot - 1);
    goto start;
  pound_include_langle : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == '\n')
      goto start;
    if (((unsigned char)__buf) != '>')
      goto pound_include_langle;
    handle_include(1, map_dot, next - map_dot - 1);
    goto start;
  pound_d : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) != 'e')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'f')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'i')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'n')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'e')
      goto __start;
    goto pound_define_undef;
  pound_u : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) != 'n')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'd')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'e')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'f')
      goto __start;
    goto pound_define_undef;
  pound_define_undef : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (((unsigned char)__buf) == ' ')
      goto pound_define_undef;
    if (((unsigned char)__buf) == '\t')
      goto pound_define_undef;
    if (((unsigned char)__buf) != 'C')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'O')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'N')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'F')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'I')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'G')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != '_')
      goto __start;
    map_dot = next;
  pound_define_undef_CONFIG_word : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (isalnum(((unsigned char)__buf)) || ((unsigned char)__buf) == '_')
      goto pound_define_undef_CONFIG_word;
    goto __start;
  cee:
    if (next >= map + 2 && (isalnum(next[-2]) || next[-2] == '_'))
      goto start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'O')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'N')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'F')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'I')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != 'G')
      goto __start;
    {
      (__buf >>= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if (((unsigned char)__buf) != '_')
      goto __start;
    map_dot = next;
  cee_CONFIG_word : {
    (__buf >>= 8);
    if ((unsigned long)next % sizeof(unsigned long) == 0) {
      if (next >= end)
        break;
      __buf = *(unsigned long *)next;
    }
    next++;
  }
    if (isalnum(((unsigned char)__buf)) || ((unsigned char)__buf) == '_')
      goto cee_CONFIG_word;
    use_config(map_dot, next - map_dot - 1);
    goto __start;
  }
}


x86 assembly (clang, -O0):
<state_machine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1191 <state_machine+0x61>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1186 <state_machine+0x56>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x43,%eax
jle    11b2 <state_machine+0x82>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x22,%eax
jge    11c7 <state_machine+0x97>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x2f,%eax
jne    11dc <state_machine+0xac>
jmp    12f4 <state_machine+0x1c4>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x27,%eax
jne    11f1 <state_machine+0xc1>
jmp    142a <state_machine+0x2fa>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x22,%eax
jne    1206 <state_machine+0xd6>
jmp    14e9 <state_machine+0x3b9>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x23,%eax
jne    121b <state_machine+0xeb>
jmp    15a8 <state_machine+0x478>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x43,%eax
jne    1230 <state_machine+0x100>
jmp    20e6 <state_machine+0xfb6>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1271 <state_machine+0x141>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1266 <state_machine+0x136>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0xa,%eax
jne    1292 <state_machine+0x162>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5c,%eax
je     12a7 <state_machine+0x177>
jmp    1235 <state_machine+0x105>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    12e3 <state_machine+0x1b3>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     12d8 <state_machine+0x1a8>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1235 <state_machine+0x105>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1330 <state_machine+0x200>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1325 <state_machine+0x1f5>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x2f,%eax
jne    1351 <state_machine+0x221>
jmp    1235 <state_machine+0x105>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x2a,%eax
je     1366 <state_machine+0x236>
jmp    119d <state_machine+0x6d>
jmp    136b <state_machine+0x23b>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    13a7 <state_machine+0x277>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     139c <state_machine+0x26c>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x2a,%eax
je     13c8 <state_machine+0x298>
jmp    136b <state_machine+0x23b>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1404 <state_machine+0x2d4>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     13f9 <state_machine+0x2c9>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x2f,%eax
je     1425 <state_machine+0x2f5>
jmp    13b3 <state_machine+0x283>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1466 <state_machine+0x336>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     145b <state_machine+0x32b>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x27,%eax
jne    1487 <state_machine+0x357>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5c,%eax
je     149c <state_machine+0x36c>
jmp    142a <state_machine+0x2fa>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    14d8 <state_machine+0x3a8>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     14cd <state_machine+0x39d>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    142a <state_machine+0x2fa>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1525 <state_machine+0x3f5>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     151a <state_machine+0x3ea>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x22,%eax
jne    1546 <state_machine+0x416>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5c,%eax
je     155b <state_machine+0x42b>
jmp    14e9 <state_machine+0x3b9>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1597 <state_machine+0x467>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     158c <state_machine+0x45c>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14e9 <state_machine+0x3b9>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    15e4 <state_machine+0x4b4>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     15d9 <state_machine+0x4a9>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x20,%eax
jne    1605 <state_machine+0x4d5>
jmp    15a8 <state_machine+0x478>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x9,%eax
jne    161a <state_machine+0x4ea>
jmp    15a8 <state_machine+0x478>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x69,%eax
jne    162f <state_machine+0x4ff>
jmp    165e <state_machine+0x52e>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x64,%eax
jne    1644 <state_machine+0x514>
jmp    1a63 <state_machine+0x933>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x75,%eax
jne    1659 <state_machine+0x529>
jmp    1c39 <state_machine+0xb09>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    169a <state_machine+0x56a>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     168f <state_machine+0x55f>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x6e,%eax
je     16bb <state_machine+0x58b>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    16f7 <state_machine+0x5c7>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     16ec <state_machine+0x5bc>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x63,%eax
je     1718 <state_machine+0x5e8>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1754 <state_machine+0x624>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1749 <state_machine+0x619>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x6c,%eax
je     1775 <state_machine+0x645>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    17b1 <state_machine+0x681>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     17a6 <state_machine+0x676>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x75,%eax
je     17d2 <state_machine+0x6a2>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    180e <state_machine+0x6de>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1803 <state_machine+0x6d3>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x64,%eax
je     182f <state_machine+0x6ff>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    186b <state_machine+0x73b>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1860 <state_machine+0x730>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x65,%eax
je     188c <state_machine+0x75c>
jmp    119d <state_machine+0x6d>
jmp    1891 <state_machine+0x761>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    18cd <state_machine+0x79d>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     18c2 <state_machine+0x792>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x20,%eax
jne    18ee <state_machine+0x7be>
jmp    1891 <state_machine+0x761>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x9,%eax
jne    1903 <state_machine+0x7d3>
jmp    1891 <state_machine+0x761>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x22,%eax
jne    1920 <state_machine+0x7f0>
jmp    193a <state_machine+0x80a>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x3c,%eax
jne    1935 <state_machine+0x805>
jmp    19cd <state_machine+0x89d>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1976 <state_machine+0x846>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     196b <state_machine+0x83b>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0xa,%eax
jne    1997 <state_machine+0x867>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x22,%eax
je     19ac <state_machine+0x87c>
jmp    193a <state_machine+0x80a>
mov    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rax
sub    %rax,%rdx
sub    $0x1,%rdx
xor    %edi,%edi
mov    $0x0,%al
call   1040 <handle_include@plt>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1a09 <state_machine+0x8d9>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     19fe <state_machine+0x8ce>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0xa,%eax
jne    1a2a <state_machine+0x8fa>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x3e,%eax
je     1a3f <state_machine+0x90f>
jmp    19cd <state_machine+0x89d>
mov    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rax
sub    %rax,%rdx
sub    $0x1,%rdx
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <handle_include@plt>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1a9f <state_machine+0x96f>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1a94 <state_machine+0x964>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x65,%eax
je     1ac0 <state_machine+0x990>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1afc <state_machine+0x9cc>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1af1 <state_machine+0x9c1>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x66,%eax
je     1b1d <state_machine+0x9ed>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1b59 <state_machine+0xa29>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1b4e <state_machine+0xa1e>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x69,%eax
je     1b7a <state_machine+0xa4a>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1bb6 <state_machine+0xa86>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1bab <state_machine+0xa7b>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x6e,%eax
je     1bd7 <state_machine+0xaa7>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1c13 <state_machine+0xae3>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1c08 <state_machine+0xad8>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x65,%eax
je     1c34 <state_machine+0xb04>
jmp    119d <state_machine+0x6d>
jmp    1db2 <state_machine+0xc82>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1c75 <state_machine+0xb45>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1c6a <state_machine+0xb3a>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x6e,%eax
je     1c96 <state_machine+0xb66>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1cd2 <state_machine+0xba2>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1cc7 <state_machine+0xb97>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x64,%eax
je     1cf3 <state_machine+0xbc3>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1d2f <state_machine+0xbff>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1d24 <state_machine+0xbf4>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x65,%eax
je     1d50 <state_machine+0xc20>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1d8c <state_machine+0xc5c>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1d81 <state_machine+0xc51>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x66,%eax
je     1dad <state_machine+0xc7d>
jmp    119d <state_machine+0x6d>
jmp    1db2 <state_machine+0xc82>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1dee <state_machine+0xcbe>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1de3 <state_machine+0xcb3>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x20,%eax
jne    1e0f <state_machine+0xcdf>
jmp    1db2 <state_machine+0xc82>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x9,%eax
jne    1e24 <state_machine+0xcf4>
jmp    1db2 <state_machine+0xc82>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x43,%eax
je     1e39 <state_machine+0xd09>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1e75 <state_machine+0xd45>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1e6a <state_machine+0xd3a>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x4f,%eax
je     1e96 <state_machine+0xd66>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1ed2 <state_machine+0xda2>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1ec7 <state_machine+0xd97>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x4e,%eax
je     1ef3 <state_machine+0xdc3>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1f2f <state_machine+0xdff>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1f24 <state_machine+0xdf4>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x46,%eax
je     1f50 <state_machine+0xe20>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1f8c <state_machine+0xe5c>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1f81 <state_machine+0xe51>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x49,%eax
je     1fad <state_machine+0xe7d>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1fe9 <state_machine+0xeb9>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1fde <state_machine+0xeae>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x47,%eax
je     200a <state_machine+0xeda>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2046 <state_machine+0xf16>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     203b <state_machine+0xf0b>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
je     2067 <state_machine+0xf37>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    20ab <state_machine+0xf7b>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     20a0 <state_machine+0xf70>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%edi
call   1030 <isalnum@plt>
cmp    $0x0,%eax
jne    20dc <state_machine+0xfac>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
jne    20e1 <state_machine+0xfb1>
jmp    206f <state_machine+0xf3f>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0x2,%rcx
cmp    %rcx,%rax
jb     2127 <state_machine+0xff7>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%edi
call   1030 <isalnum@plt>
cmp    $0x0,%eax
jne    2122 <state_machine+0xff2>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%eax
cmp    $0x5f,%eax
jne    2127 <state_machine+0xff7>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2163 <state_machine+0x1033>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2158 <state_machine+0x1028>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x4f,%eax
je     2184 <state_machine+0x1054>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    21c0 <state_machine+0x1090>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     21b5 <state_machine+0x1085>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x4e,%eax
je     21e1 <state_machine+0x10b1>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    221d <state_machine+0x10ed>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2212 <state_machine+0x10e2>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x46,%eax
je     223e <state_machine+0x110e>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    227a <state_machine+0x114a>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     226f <state_machine+0x113f>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x49,%eax
je     229b <state_machine+0x116b>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    22d7 <state_machine+0x11a7>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     22cc <state_machine+0x119c>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x47,%eax
je     22f8 <state_machine+0x11c8>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2334 <state_machine+0x1204>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2329 <state_machine+0x11f9>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
je     2355 <state_machine+0x1225>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2399 <state_machine+0x1269>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     238e <state_machine+0x125e>
jmp    23ee <state_machine+0x12be>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
movzbl %al,%edi
call   1030 <isalnum@plt>
cmp    $0x0,%eax
jne    23ca <state_machine+0x129a>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
jne    23cf <state_machine+0x129f>
jmp    235d <state_machine+0x122d>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rax
sub    %rax,%rsi
sub    $0x1,%rsi
mov    $0x0,%al
call   1050 <use_config@plt>
jmp    119d <state_machine+0x6d>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<state_machine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r8
mov    %rdi,%r14
lea    0x7(%rdi),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0x10(%rsp)
lea    0xea3(%rip),%r9
xor    %ebp,%ebp
xor    %r13d,%r13d
mov    %rsi,(%rsp)
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1180 <state_machine+0x50>
shr    $0x8,%r13
add    $0x1,%rbp
jmp    1190 <state_machine+0x60>
nopl   0x0(%rax,%rax,1)
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
add    $0x1,%rbp
movzbl %r13b,%eax
add    $0xffffffbc,%eax
cmp    $0xffffffde,%eax
jb     1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rbx
lea    -0x22(%r13),%eax
movzbl %al,%eax
cmp    $0x21,%al
ja     1166 <state_machine+0x36>
movslq (%r9,%rax,4),%rax
add    %r9,%rax
jmp    *%rax
lea    0x3(%rbp),%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%rcx
lea    (%rdx,%rbp,1),%rdi
jmp    11ea <state_machine+0xba>
nopw   0x0(%rax,%rax,1)
cmp    $0x9,%r13b
jne    140a <state_machine+0x2da>
add    $0x1,%rax
add    $0x1,%rbp
add    $0x1,%rcx
add    $0x1,%rdi
lea    (%r14,%rax,1),%rdx
add    $0xfffffffffffffffd,%rdx
test   $0x7,%dl
je     1210 <state_machine+0xe0>
shr    $0x8,%r13
cmp    $0x1f,%r13b
jg     1224 <state_machine+0xf4>
jmp    11d0 <state_machine+0xa0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    -0x3(%r14,%rax,1),%r13
cmp    $0x1f,%r13b
jle    11d0 <state_machine+0xa0>
cmp    $0x63,%r13b
jg     1338 <state_machine+0x208>
cmp    $0x20,%r13b
je     11da <state_machine+0xaa>
jmp    140a <state_machine+0x2da>
nopl   0x0(%rax)
test   $0x7,%bl
je     137a <state_machine+0x24a>
shr    $0x8,%r13
jmp    1386 <state_machine+0x256>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x2,%rbp
jl     1290 <state_machine+0x160>
mov    -0x2(%rbx),%r15b
movsbl %r15b,%edi
call   1030 <isalnum@plt>
test   %eax,%eax
jne    1c7c <state_machine+0xb4c>
cmp    $0x5f,%r15b
mov    (%rsp),%r8
lea    0xd76(%rip),%r9
je     1166 <state_machine+0x36>
test   $0x7,%bl
je     13a3 <state_machine+0x273>
shr    $0x8,%r13
cmp    $0x4f,%r13b
jne    13b9 <state_machine+0x289>
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1416 <state_machine+0x2e6>
shr    $0x8,%r13
cmp    $0x4e,%r13b
jne    142c <state_machine+0x2fc>
lea    (%r14,%rbp,1),%rax
add    $0x2,%rax
test   $0x7,%al
je     1435 <state_machine+0x305>
shr    $0x8,%r13
cmp    $0x46,%r13b
jne    144b <state_machine+0x31b>
lea    (%r14,%rbp,1),%rax
add    $0x3,%rax
test   $0x7,%al
je     1505 <state_machine+0x3d5>
shr    $0x8,%r13
cmp    $0x49,%r13b
jne    151b <state_machine+0x3eb>
lea    (%r14,%rbp,1),%rax
add    $0x4,%rax
test   $0x7,%al
je     15e4 <state_machine+0x4b4>
shr    $0x8,%r13
cmp    $0x47,%r13b
jne    15fa <state_machine+0x4ca>
lea    (%r14,%rbp,1),%rax
add    $0x5,%rax
test   $0x7,%al
je     16b7 <state_machine+0x587>
shr    $0x8,%r13
jmp    16c3 <state_machine+0x593>
cmp    $0x64,%r13b
je     13c2 <state_machine+0x292>
cmp    $0x69,%r13b
je     13e6 <state_machine+0x2b6>
cmp    $0x75,%r13b
jne    140a <state_machine+0x2da>
lea    (%r14,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     1454 <state_machine+0x324>
shr    $0x8,%r13
cmp    $0x6e,%r13b
je     146c <state_machine+0x33c>
jmp    14f9 <state_machine+0x3c9>
cmp    %r8,%rbx
jae    1d3c <state_machine+0xc0c>
mov    (%rbx),%r13
add    $0x1,%rbp
cmp    $0x2f,%r13b
je     1bbe <state_machine+0xa8e>
cmp    $0x2a,%r13b
jne    1190 <state_machine+0x60>
jmp    1c64 <state_machine+0xb34>
cmp    %r8,%rbx
jae    1d3c <state_machine+0xc0c>
mov    (%rbx),%r13
cmp    $0x4f,%r13b
je     12a7 <state_machine+0x177>
add    $0x1,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     148b <state_machine+0x35b>
shr    $0x8,%r13
cmp    $0x65,%r13b
je     149f <state_machine+0x36f>
jmp    14f9 <state_machine+0x3c9>
lea    (%r14,%rax,1),%rdx
add    $0xfffffffffffffffe,%rdx
test   $0x7,%dl
je     14c2 <state_machine+0x392>
shr    $0x8,%r13
cmp    $0x6e,%r13b
je     14d6 <state_machine+0x3a6>
jmp    14f9 <state_machine+0x3c9>
add    $0xfffffffffffffffe,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x4e,%r13b
je     12c5 <state_machine+0x195>
add    $0x2,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x46,%r13b
je     12e3 <state_machine+0x1b3>
add    $0x3,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    -0x2(%r14,%rax,1),%r13
cmp    $0x6e,%r13b
jne    14f9 <state_machine+0x3c9>
lea    (%r14,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     1524 <state_machine+0x3f4>
shr    $0x8,%r13
cmp    $0x64,%r13b
jne    140e <state_machine+0x2de>
jmp    1544 <state_machine+0x414>
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    -0x2(%r14,%rax,1),%r13
cmp    $0x65,%r13b
jne    14f9 <state_machine+0x3c9>
lea    (%r14,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     1564 <state_machine+0x434>
shr    $0x8,%r13
cmp    $0x66,%r13b
jne    140e <state_machine+0x2de>
jmp    1584 <state_machine+0x454>
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    -0x2(%r14,%rax,1),%r13
cmp    $0x6e,%r13b
jne    14f9 <state_machine+0x3c9>
lea    (%r14,%rax,1),%edx
add    $0xffffffff,%edx
test   $0x7,%dl
je     15a4 <state_machine+0x474>
shr    $0x8,%r13
cmp    $0x63,%r13b
jne    140e <state_machine+0x2de>
jmp    15c4 <state_machine+0x494>
add    $0xffffffffffffffff,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x49,%r13b
je     1301 <state_machine+0x1d1>
add    $0x4,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    -0x1(%r14,%rax,1),%r13
cmp    $0x64,%r13b
jne    140e <state_machine+0x2de>
lea    (%r14,%rax,1),%ecx
test   $0x7,%cl
je     1603 <state_machine+0x4d3>
shr    $0x8,%r13
cmp    $0x65,%r13b
je     161e <state_machine+0x4ee>
jmp    16ab <state_machine+0x57b>
lea    (%r14,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    -0x1(%r14,%rax,1),%r13
cmp    $0x66,%r13b
jne    140e <state_machine+0x2de>
lea    (%r14,%rax,1),%ecx
test   $0x7,%cl
je     1637 <state_machine+0x507>
shr    $0x8,%r13
cmp    $0x69,%r13b
je     164e <state_machine+0x51e>
jmp    16ab <state_machine+0x57b>
lea    (%r14,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    -0x1(%r14,%rax,1),%r13
cmp    $0x63,%r13b
jne    140e <state_machine+0x2de>
lea    (%r14,%rax,1),%edx
test   $0x7,%dl
je     1671 <state_machine+0x541>
shr    $0x8,%r13
cmp    $0x6c,%r13b
je     1688 <state_machine+0x558>
jmp    16ab <state_machine+0x57b>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x47,%r13b
je     131f <state_machine+0x1ef>
add    $0x5,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%rax,1),%r13
cmp    $0x65,%r13b
jne    16ab <state_machine+0x57b>
lea    (%r14,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     1742 <state_machine+0x612>
shr    $0x8,%r13
jmp    1758 <state_machine+0x628>
lea    (%r14,%rax,1),%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%rax,1),%r13
cmp    $0x69,%r13b
jne    16ab <state_machine+0x57b>
lea    (%r14,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     176e <state_machine+0x63e>
shr    $0x8,%r13
cmp    $0x6e,%r13b
je     178a <state_machine+0x65a>
jmp    17ef <state_machine+0x6bf>
lea    (%r14,%rax,1),%rdx
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%rax,1),%r13
cmp    $0x6c,%r13b
jne    16ab <state_machine+0x57b>
lea    (%r14,%rax,1),%edx
add    $0x1,%edx
test   $0x7,%dl
je     179c <state_machine+0x66c>
shr    $0x8,%r13
cmp    $0x75,%r13b
je     17b8 <state_machine+0x688>
jmp    17ef <state_machine+0x6bf>
add    $0x1,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
lea    0x6(%rbp),%r15
cmp    $0x5f,%r13b
jne    173a <state_machine+0x60a>
lea    (%r14,%rbp,1),%rbx
add    $0x6,%rbx
mov    $0xffffffffffffffff,%r12
nopl   0x0(%rax)
lea    (%r14,%r15,1),%rax
test   $0x7,%al
je     16f0 <state_machine+0x5c0>
shr    $0x8,%r13
jmp    16fe <state_machine+0x5ce>
xchg   %ax,%ax
cmp    (%rsp),%rax
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%r15,1),%r13
add    $0x1,%r15
movzbl %r13b,%ebp
mov    %ebp,%edi
call   1030 <isalnum@plt>
add    $0x1,%r12
test   %eax,%eax
jne    16e0 <state_machine+0x5b0>
cmp    $0x5f,%ebp
je     16e0 <state_machine+0x5b0>
mov    %rbx,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <use_config@plt>
lea    0x8d2(%rip),%r9
mov    %r15,%rbp
mov    (%rsp),%r8
jmp    1190 <state_machine+0x60>
mov    %r15,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    0x1(%r14,%rax,1),%r13
add    $0x2,%rax
mov    %rax,%rbp
cmp    $0x66,%r13b
jne    1190 <state_machine+0x60>
jmp    1822 <state_machine+0x6f2>
lea    (%r14,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    0x1(%r14,%rax,1),%r13
cmp    $0x6e,%r13b
jne    17ef <state_machine+0x6bf>
lea    (%r14,%rax,1),%ecx
add    $0x2,%ecx
test   $0x7,%cl
je     17fb <state_machine+0x6cb>
shr    $0x8,%r13
jmp    1811 <state_machine+0x6e1>
lea    (%r14,%rax,1),%rdx
add    $0x1,%rdx
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    0x1(%r14,%rax,1),%r13
cmp    $0x75,%r13b
jne    17ef <state_machine+0x6bf>
lea    (%r14,%rax,1),%edx
add    $0x2,%edx
test   $0x7,%dl
je     188b <state_machine+0x75b>
shr    $0x8,%r13
cmp    $0x64,%r13b
jne    18ab <state_machine+0x77b>
lea    (%r14,%rax,1),%edx
add    $0x3,%edx
test   $0x7,%dl
je     18ec <state_machine+0x7bc>
shr    $0x8,%r13
jmp    1902 <state_machine+0x7d2>
add    $0x2,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rcx
add    $0x2,%rcx
cmp    %r8,%rcx
jae    1d3c <state_machine+0xc0c>
mov    0x2(%r14,%rax,1),%r13
add    $0x3,%rax
mov    %rax,%rbp
cmp    $0x65,%r13b
jne    1190 <state_machine+0x60>
add    $0x7,%rax
mov    %rax,%rbp
jmp    1834 <state_machine+0x704>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffff9,%rax
test   $0x7,%al
je     1850 <state_machine+0x720>
shr    $0x8,%r13
cmp    $0x9,%r13b
jne    1864 <state_machine+0x734>
jmp    1830 <state_machine+0x700>
nopl   0x0(%rax)
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x7(%r14,%rbp,1),%r13
cmp    $0x9,%r13b
je     1830 <state_machine+0x700>
cmp    $0x20,%r13b
je     1830 <state_machine+0x700>
cmp    $0x43,%r13b
jne    1882 <state_machine+0x752>
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffffa,%rax
test   $0x7,%al
je     18b7 <state_machine+0x787>
shr    $0x8,%r13
jmp    18c5 <state_machine+0x795>
add    $0xfffffffffffffffa,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rdx
add    $0x2,%rdx
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    0x2(%r14,%rax,1),%r13
cmp    $0x64,%r13b
je     17d6 <state_machine+0x6a6>
add    $0x3,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x6(%r14,%rbp,1),%r13
cmp    $0x4f,%r13b
jne    18e3 <state_machine+0x7b3>
lea    (%r14,%rbp,1),%eax
add    $0xfffffffb,%eax
test   $0x7,%al
je     1984 <state_machine+0x854>
shr    $0x8,%r13
jmp    199a <state_machine+0x86a>
add    $0xfffffffffffffffb,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rax,1),%rdx
add    $0x3,%rdx
cmp    %r8,%rdx
jae    1d3c <state_machine+0xc0c>
mov    0x3(%r14,%rax,1),%r13
cmp    $0x65,%r13b
jne    1978 <state_machine+0x848>
mov    0x8(%rsp),%rdx
jmp    1921 <state_machine+0x7f1>
cmp    $0x9,%r13b
jne    196f <state_machine+0x83f>
add    $0x1,%rbp
add    $0x1,%rcx
add    $0x1,%rdi
lea    (%rdx,%rbp,1),%eax
test   $0x7,%al
je     1934 <state_machine+0x804>
shr    $0x8,%r13
cmp    $0x1f,%r13b
jg     1955 <state_machine+0x825>
jmp    190f <state_machine+0x7df>
lea    (%r14,%rbp,1),%rax
add    $0x7,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    0x7(%r14,%rbp,1),%r13
mov    0x8(%rsp),%rdx
cmp    $0x1f,%r13b
jle    190f <state_machine+0x7df>
cmp    $0x20,%r13b
je     1915 <state_machine+0x7e5>
cmp    $0x22,%r13b
je     1c8c <state_machine+0xb5c>
cmp    $0x3c,%r13b
je     1cda <state_machine+0xbaa>
add    $0x8,%rbp
jmp    1190 <state_machine+0x60>
add    $0x4,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffffb,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x5(%r14,%rbp,1),%r13
cmp    $0x4e,%r13b
jne    19b1 <state_machine+0x881>
lea    (%r14,%rbp,1),%eax
add    $0xfffffffc,%eax
test   $0x7,%al
je     19ba <state_machine+0x88a>
shr    $0x8,%r13
jmp    19d0 <state_machine+0x8a0>
add    $0xfffffffffffffffc,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x4(%r14,%rbp,1),%r13
cmp    $0x46,%r13b
jne    19e7 <state_machine+0x8b7>
lea    (%r14,%rbp,1),%eax
add    $0xfffffffd,%eax
test   $0x7,%al
je     19f0 <state_machine+0x8c0>
shr    $0x8,%r13
jmp    1a06 <state_machine+0x8d6>
add    $0xfffffffffffffffd,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffffd,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x3(%r14,%rbp,1),%r13
cmp    $0x49,%r13b
jne    1a1d <state_machine+0x8ed>
lea    (%r14,%rbp,1),%eax
add    $0xfffffffe,%eax
test   $0x7,%al
je     1a26 <state_machine+0x8f6>
shr    $0x8,%r13
jmp    1a3c <state_machine+0x90c>
add    $0xfffffffffffffffe,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
add    $0xfffffffffffffffe,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x2(%r14,%rbp,1),%r13
cmp    $0x47,%r13b
jne    1a53 <state_machine+0x923>
lea    (%r14,%rbp,1),%eax
add    $0xffffffff,%eax
test   $0x7,%al
je     1a5c <state_machine+0x92c>
shr    $0x8,%r13
jmp    1a72 <state_machine+0x942>
add    $0xffffffffffffffff,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    -0x1(%r14,%rbp,1),%r13
cmp    $0x5f,%r13b
jne    1190 <state_machine+0x60>
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1a8a <state_machine+0x95a>
shr    $0x8,%r13
jmp    1a97 <state_machine+0x967>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%rbp,1),%r13
add    $0x1,%rbp
movzbl %r13b,%r12d
mov    %r12d,%edi
call   1030 <isalnum@plt>
test   %eax,%eax
mov    (%rsp),%r8
lea    0x54c(%rip),%r9
jne    1a7c <state_machine+0x94c>
cmp    $0x5f,%r12d
je     1a7c <state_machine+0x94c>
jmp    1190 <state_machine+0x60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x22,%r13b
je     1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1b00 <state_machine+0x9d0>
shr    $0x8,%r13
cmp    $0x5c,%r13b
jne    1ad0 <state_machine+0x9a0>
jmp    1b12 <state_machine+0x9e2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x5c,%r13b
jne    1ad0 <state_machine+0x9a0>
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1b28 <state_machine+0x9f8>
shr    $0x8,%r13
add    $0x2,%rbp
jmp    1ade <state_machine+0x9ae>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1ade <state_machine+0x9ae>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x27,%r13b
je     1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1b70 <state_machine+0xa40>
shr    $0x8,%r13
cmp    $0x5c,%r13b
jne    1b40 <state_machine+0xa10>
jmp    1b82 <state_machine+0xa52>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x5c,%r13b
jne    1b40 <state_machine+0xa10>
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1b98 <state_machine+0xa68>
shr    $0x8,%r13
add    $0x2,%rbp
jmp    1b4e <state_machine+0xa1e>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1b4e <state_machine+0xa1e>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0xa,%r13b
je     1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1be0 <state_machine+0xab0>
shr    $0x8,%r13
cmp    $0x5c,%r13b
jne    1bb0 <state_machine+0xa80>
jmp    1bf2 <state_machine+0xac2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
cmp    $0x5c,%r13b
jne    1bb0 <state_machine+0xa80>
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1c08 <state_machine+0xad8>
shr    $0x8,%r13
add    $0x2,%rbp
jmp    1bbe <state_machine+0xa8e>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1bbe <state_machine+0xa8e>
mov    (%rax),%r13
add    $0x1,%rbp
jmp    1c42 <state_machine+0xb12>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
shr    $0x8,%r13
add    $0x1,%rbp
cmp    $0x2f,%r13b
je     1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rax
cmp    $0x2a,%r13b
jne    1c64 <state_machine+0xb34>
lea    (%r14,%rbp,1),%ecx
test   $0x7,%cl
jne    1c30 <state_machine+0xb00>
cmp    %r8,%rax
jae    1d3c <state_machine+0xc0c>
mov    (%r14,%rbp,1),%r13
jmp    1c34 <state_machine+0xb04>
lea    (%r14,%rbp,1),%rax
test   $0x7,%al
je     1c72 <state_machine+0xb42>
shr    $0x8,%r13
jmp    1c1d <state_machine+0xaed>
cmp    %r8,%rax
jb     1c1a <state_machine+0xaea>
jmp    1d3c <state_machine+0xc0c>
mov    (%rsp),%r8
lea    0x379(%rip),%r9
jmp    1166 <state_machine+0x36>
lea    (%r14,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffffffffffff,%rdx
test   $0x7,%cl
je     1caa <state_machine+0xb7a>
shr    $0x8,%r13
jmp    1cb6 <state_machine+0xb86>
cmp    %r8,%rdi
jae    1d3c <state_machine+0xc0c>
mov    (%rdi),%r13
add    $0x1,%rbp
cmp    $0xa,%r13b
je     1166 <state_machine+0x36>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%rdx
cmp    $0x22,%r13b
jne    1c9f <state_machine+0xb6f>
xor    %edi,%edi
jmp    1d25 <state_machine+0xbf5>
lea    (%r14,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffffffffffff,%rdx
test   $0x7,%cl
je     1cf8 <state_machine+0xbc8>
shr    $0x8,%r13
jmp    1d00 <state_machine+0xbd0>
cmp    %r8,%rdi
jae    1d3c <state_machine+0xc0c>
mov    (%rdi),%r13
add    $0x1,%rbp
cmp    $0xa,%r13b
je     1166 <state_machine+0x36>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%rdx
cmp    $0x3e,%r13b
jne    1ced <state_machine+0xbbd>
mov    $0x1,%edi
xor    %eax,%eax
call   1040 <handle_include@plt>
lea    0x2cd(%rip),%r9
mov    (%rsp),%r8
jmp    1166 <state_machine+0x36>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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