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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ handle_include(int, char const *, int);
scalar_t__ isalnum(unsigned char);
int /*<<< orphan*/ use_config(char const *, int);
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((int)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    23f4 <state_machine+0x12c4>
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    20e7 <state_machine+0xfb7>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,%edx
xor    %edi,%edi
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    23f4 <state_machine+0x12c4>
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),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,%edx
mov    $0x1,%edi
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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    23f4 <state_machine+0x12c4>
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,%rax
jne    20dd <state_machine+0xfad>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
jne    20e2 <state_machine+0xfb2>
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     212c <state_machine+0xffc>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%eax
movzbl %al,%edi
call   1030 <isalnum@plt>
cmp    $0x0,%rax
jne    2127 <state_machine+0xff7>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%eax
cmp    $0x5f,%eax
jne    212c <state_machine+0xffc>
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    2168 <state_machine+0x1038>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     215d <state_machine+0x102d>
jmp    23f4 <state_machine+0x12c4>
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     2189 <state_machine+0x1059>
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    21c5 <state_machine+0x1095>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     21ba <state_machine+0x108a>
jmp    23f4 <state_machine+0x12c4>
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     21e6 <state_machine+0x10b6>
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    2222 <state_machine+0x10f2>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2217 <state_machine+0x10e7>
jmp    23f4 <state_machine+0x12c4>
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     2243 <state_machine+0x1113>
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    227f <state_machine+0x114f>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2274 <state_machine+0x1144>
jmp    23f4 <state_machine+0x12c4>
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     22a0 <state_machine+0x1170>
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    22dc <state_machine+0x11ac>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     22d1 <state_machine+0x11a1>
jmp    23f4 <state_machine+0x12c4>
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     22fd <state_machine+0x11cd>
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    2339 <state_machine+0x1209>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     232e <state_machine+0x11fe>
jmp    23f4 <state_machine+0x12c4>
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     235a <state_machine+0x122a>
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    239e <state_machine+0x126e>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2393 <state_machine+0x1263>
jmp    23f4 <state_machine+0x12c4>
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,%rax
jne    23d0 <state_machine+0x12a0>
mov    -0x28(%rbp),%rax
movzbl %al,%eax
cmp    $0x5f,%eax
jne    23d5 <state_machine+0x12a5>
jmp    2362 <state_machine+0x1232>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,%esi
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,%r14
mov    %rdi,%r12
lea    0x7(%rdi),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0x10(%rsp)
xor    %ebp,%ebp
lea    0xea1(%rip),%r8
xor    %r15d,%r15d
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1180 <state_machine+0x50>
shr    $0x8,%r15
add    $0x1,%rbp
jmp    1190 <state_machine+0x60>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
add    $0x1,%rbp
movzbl %r15b,%eax
add    $0xffffffbc,%eax
cmp    $0xffffffde,%eax
jb     1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rbx
lea    -0x22(%r15),%eax
movzbl %al,%eax
cmp    $0x21,%al
ja     1162 <state_machine+0x32>
movslq (%r8,%rax,4),%rax
add    %r8,%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,%r15b
jne    1403 <state_machine+0x2d3>
add    $0x1,%rax
add    $0x1,%rbp
add    $0x1,%rcx
add    $0x1,%rdi
lea    (%r12,%rax,1),%rdx
add    $0xfffffffffffffffd,%rdx
test   $0x7,%dl
je     1210 <state_machine+0xe0>
shr    $0x8,%r15
cmp    $0x1f,%r15b
jg     1224 <state_machine+0xf4>
jmp    11d0 <state_machine+0xa0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    -0x3(%r12,%rax,1),%r15
cmp    $0x1f,%r15b
jle    11d0 <state_machine+0xa0>
cmp    $0x63,%r15b
jg     1331 <state_machine+0x201>
cmp    $0x20,%r15b
je     11da <state_machine+0xaa>
jmp    1403 <state_machine+0x2d3>
nopl   0x0(%rax)
test   $0x7,%bl
je     1373 <state_machine+0x243>
shr    $0x8,%r15
jmp    137f <state_machine+0x24f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x2,%rbp
jl     1289 <state_machine+0x159>
movzbl -0x2(%rbx),%edi
call   1030 <isalnum@plt>
test   %rax,%rax
jne    1c6c <state_machine+0xb3c>
cmpb   $0x5f,-0x2(%rbx)
lea    0xd7d(%rip),%r8
je     1162 <state_machine+0x32>
test   $0x7,%bl
je     139c <state_machine+0x26c>
shr    $0x8,%r15
cmp    $0x4f,%r15b
jne    13b2 <state_machine+0x282>
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     140f <state_machine+0x2df>
shr    $0x8,%r15
cmp    $0x4e,%r15b
jne    1425 <state_machine+0x2f5>
lea    (%r12,%rbp,1),%rax
add    $0x2,%rax
test   $0x7,%al
je     142e <state_machine+0x2fe>
shr    $0x8,%r15
cmp    $0x46,%r15b
jne    1444 <state_machine+0x314>
lea    (%r12,%rbp,1),%rax
add    $0x3,%rax
test   $0x7,%al
je     14fe <state_machine+0x3ce>
shr    $0x8,%r15
cmp    $0x49,%r15b
jne    1514 <state_machine+0x3e4>
lea    (%r12,%rbp,1),%rax
add    $0x4,%rax
test   $0x7,%al
je     15dd <state_machine+0x4ad>
shr    $0x8,%r15
cmp    $0x47,%r15b
jne    15f3 <state_machine+0x4c3>
lea    (%r12,%rbp,1),%rax
add    $0x5,%rax
test   $0x7,%al
je     16b0 <state_machine+0x580>
shr    $0x8,%r15
jmp    16bc <state_machine+0x58c>
cmp    $0x64,%r15b
je     13bb <state_machine+0x28b>
cmp    $0x69,%r15b
je     13df <state_machine+0x2af>
cmp    $0x75,%r15b
jne    1403 <state_machine+0x2d3>
lea    (%r12,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     144d <state_machine+0x31d>
shr    $0x8,%r15
cmp    $0x6e,%r15b
je     1465 <state_machine+0x335>
jmp    14f2 <state_machine+0x3c2>
cmp    %r14,%rbx
jae    1d18 <state_machine+0xbe8>
mov    (%rbx),%r15
add    $0x1,%rbp
cmp    $0x2f,%r15b
je     1bae <state_machine+0xa7e>
cmp    $0x2a,%r15b
jne    1190 <state_machine+0x60>
jmp    1c54 <state_machine+0xb24>
cmp    %r14,%rbx
jae    1d18 <state_machine+0xbe8>
mov    (%rbx),%r15
cmp    $0x4f,%r15b
je     12a0 <state_machine+0x170>
add    $0x1,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     1484 <state_machine+0x354>
shr    $0x8,%r15
cmp    $0x65,%r15b
je     1498 <state_machine+0x368>
jmp    14f2 <state_machine+0x3c2>
lea    (%r12,%rax,1),%rdx
add    $0xfffffffffffffffe,%rdx
test   $0x7,%dl
je     14bb <state_machine+0x38b>
shr    $0x8,%r15
cmp    $0x6e,%r15b
je     14cf <state_machine+0x39f>
jmp    14f2 <state_machine+0x3c2>
add    $0xfffffffffffffffe,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x4e,%r15b
je     12be <state_machine+0x18e>
add    $0x2,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x46,%r15b
je     12dc <state_machine+0x1ac>
add    $0x3,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    -0x2(%r12,%rax,1),%r15
cmp    $0x6e,%r15b
jne    14f2 <state_machine+0x3c2>
lea    (%r12,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     151d <state_machine+0x3ed>
shr    $0x8,%r15
cmp    $0x64,%r15b
jne    1407 <state_machine+0x2d7>
jmp    153d <state_machine+0x40d>
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    -0x2(%r12,%rax,1),%r15
cmp    $0x65,%r15b
jne    14f2 <state_machine+0x3c2>
lea    (%r12,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     155d <state_machine+0x42d>
shr    $0x8,%r15
cmp    $0x66,%r15b
jne    1407 <state_machine+0x2d7>
jmp    157d <state_machine+0x44d>
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    -0x2(%r12,%rax,1),%r15
cmp    $0x6e,%r15b
jne    14f2 <state_machine+0x3c2>
lea    (%r12,%rax,1),%edx
add    $0xffffffff,%edx
test   $0x7,%dl
je     159d <state_machine+0x46d>
shr    $0x8,%r15
cmp    $0x63,%r15b
jne    1407 <state_machine+0x2d7>
jmp    15bd <state_machine+0x48d>
add    $0xffffffffffffffff,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x49,%r15b
je     12fa <state_machine+0x1ca>
add    $0x4,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    -0x1(%r12,%rax,1),%r15
cmp    $0x64,%r15b
jne    1407 <state_machine+0x2d7>
lea    (%r12,%rax,1),%ecx
test   $0x7,%cl
je     15fc <state_machine+0x4cc>
shr    $0x8,%r15
cmp    $0x65,%r15b
je     1617 <state_machine+0x4e7>
jmp    16a4 <state_machine+0x574>
lea    (%r12,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    -0x1(%r12,%rax,1),%r15
cmp    $0x66,%r15b
jne    1407 <state_machine+0x2d7>
lea    (%r12,%rax,1),%ecx
test   $0x7,%cl
je     1630 <state_machine+0x500>
shr    $0x8,%r15
cmp    $0x69,%r15b
je     1647 <state_machine+0x517>
jmp    16a4 <state_machine+0x574>
lea    (%r12,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    -0x1(%r12,%rax,1),%r15
cmp    $0x63,%r15b
jne    1407 <state_machine+0x2d7>
lea    (%r12,%rax,1),%edx
test   $0x7,%dl
je     166a <state_machine+0x53a>
shr    $0x8,%r15
cmp    $0x6c,%r15b
je     1681 <state_machine+0x551>
jmp    16a4 <state_machine+0x574>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x47,%r15b
je     1318 <state_machine+0x1e8>
add    $0x5,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%rax,1),%r15
cmp    $0x65,%r15b
jne    16a4 <state_machine+0x574>
lea    (%r12,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     173c <state_machine+0x60c>
shr    $0x8,%r15
jmp    1752 <state_machine+0x622>
lea    (%r12,%rax,1),%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%rax,1),%r15
cmp    $0x69,%r15b
jne    16a4 <state_machine+0x574>
lea    (%r12,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     1768 <state_machine+0x638>
shr    $0x8,%r15
cmp    $0x6e,%r15b
je     1784 <state_machine+0x654>
jmp    17e9 <state_machine+0x6b9>
lea    (%r12,%rax,1),%rdx
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%rax,1),%r15
cmp    $0x6c,%r15b
jne    16a4 <state_machine+0x574>
lea    (%r12,%rax,1),%edx
add    $0x1,%edx
test   $0x7,%dl
je     1796 <state_machine+0x666>
shr    $0x8,%r15
cmp    $0x75,%r15b
je     17b2 <state_machine+0x682>
jmp    17e9 <state_machine+0x6b9>
add    $0x1,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
lea    0x6(%rbp),%r13
cmp    $0x5f,%r15b
jne    1734 <state_machine+0x604>
lea    (%r12,%rbp,1),%rbx
add    $0x6,%rbx
mov    $0xffffffff,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r12,%r13,1),%rax
test   $0x7,%al
je     16f0 <state_machine+0x5c0>
shr    $0x8,%r15
jmp    16fd <state_machine+0x5cd>
xchg   %ax,%ax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%r13,1),%r15
add    $0x1,%r13
movzbl %r15b,%edi
call   1030 <isalnum@plt>
add    $0x1,%ebp
test   %rax,%rax
jne    16e0 <state_machine+0x5b0>
movzbl %r15b,%eax
cmp    $0x5f,%eax
je     16e0 <state_machine+0x5b0>
mov    %rbx,%rdi
mov    %ebp,%esi
call   1050 <use_config@plt>
lea    0x8d4(%rip),%r8
mov    %r13,%rbp
jmp    1190 <state_machine+0x60>
mov    %r13,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    0x1(%r12,%rax,1),%r15
add    $0x2,%rax
mov    %rax,%rbp
cmp    $0x66,%r15b
jne    1190 <state_machine+0x60>
jmp    181c <state_machine+0x6ec>
lea    (%r12,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    0x1(%r12,%rax,1),%r15
cmp    $0x6e,%r15b
jne    17e9 <state_machine+0x6b9>
lea    (%r12,%rax,1),%ecx
add    $0x2,%ecx
test   $0x7,%cl
je     17f5 <state_machine+0x6c5>
shr    $0x8,%r15
jmp    180b <state_machine+0x6db>
lea    (%r12,%rax,1),%rdx
add    $0x1,%rdx
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    0x1(%r12,%rax,1),%r15
cmp    $0x75,%r15b
jne    17e9 <state_machine+0x6b9>
lea    (%r12,%rax,1),%edx
add    $0x2,%edx
test   $0x7,%dl
je     188b <state_machine+0x75b>
shr    $0x8,%r15
cmp    $0x64,%r15b
jne    18ab <state_machine+0x77b>
lea    (%r12,%rax,1),%edx
add    $0x3,%edx
test   $0x7,%dl
je     18ec <state_machine+0x7bc>
shr    $0x8,%r15
jmp    1902 <state_machine+0x7d2>
add    $0x2,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rcx
add    $0x2,%rcx
cmp    %r14,%rcx
jae    1d18 <state_machine+0xbe8>
mov    0x2(%r12,%rax,1),%r15
add    $0x3,%rax
mov    %rax,%rbp
cmp    $0x65,%r15b
jne    1190 <state_machine+0x60>
add    $0x7,%rax
mov    %rax,%rbp
jmp    1834 <state_machine+0x704>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffff9,%rax
test   $0x7,%al
je     1850 <state_machine+0x720>
shr    $0x8,%r15
cmp    $0x9,%r15b
jne    1864 <state_machine+0x734>
jmp    1830 <state_machine+0x700>
nopl   0x0(%rax)
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x7(%r12,%rbp,1),%r15
cmp    $0x9,%r15b
je     1830 <state_machine+0x700>
cmp    $0x20,%r15b
je     1830 <state_machine+0x700>
cmp    $0x43,%r15b
jne    1882 <state_machine+0x752>
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffffa,%rax
test   $0x7,%al
je     18b7 <state_machine+0x787>
shr    $0x8,%r15
jmp    18c5 <state_machine+0x795>
add    $0xfffffffffffffffa,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rdx
add    $0x2,%rdx
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    0x2(%r12,%rax,1),%r15
cmp    $0x64,%r15b
je     17d0 <state_machine+0x6a0>
add    $0x3,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x6(%r12,%rbp,1),%r15
cmp    $0x4f,%r15b
jne    18e3 <state_machine+0x7b3>
lea    (%r12,%rbp,1),%eax
add    $0xfffffffb,%eax
test   $0x7,%al
je     1984 <state_machine+0x854>
shr    $0x8,%r15
jmp    199a <state_machine+0x86a>
add    $0xfffffffffffffffb,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rax,1),%rdx
add    $0x3,%rdx
cmp    %r14,%rdx
jae    1d18 <state_machine+0xbe8>
mov    0x3(%r12,%rax,1),%r15
cmp    $0x65,%r15b
jne    1978 <state_machine+0x848>
mov    0x8(%rsp),%rdx
jmp    1921 <state_machine+0x7f1>
cmp    $0x9,%r15b
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,%r15
cmp    $0x1f,%r15b
jg     1955 <state_machine+0x825>
jmp    190f <state_machine+0x7df>
lea    (%r12,%rbp,1),%rax
add    $0x7,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    0x7(%r12,%rbp,1),%r15
mov    0x8(%rsp),%rdx
cmp    $0x1f,%r15b
jle    190f <state_machine+0x7df>
cmp    $0x20,%r15b
je     1915 <state_machine+0x7e5>
cmp    $0x22,%r15b
je     1c78 <state_machine+0xb48>
cmp    $0x3c,%r15b
je     1cbf <state_machine+0xb8f>
add    $0x8,%rbp
jmp    1190 <state_machine+0x60>
add    $0x4,%rax
mov    %rax,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffffb,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x5(%r12,%rbp,1),%r15
cmp    $0x4e,%r15b
jne    19b1 <state_machine+0x881>
lea    (%r12,%rbp,1),%eax
add    $0xfffffffc,%eax
test   $0x7,%al
je     19ba <state_machine+0x88a>
shr    $0x8,%r15
jmp    19d0 <state_machine+0x8a0>
add    $0xfffffffffffffffc,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x4(%r12,%rbp,1),%r15
cmp    $0x46,%r15b
jne    19e7 <state_machine+0x8b7>
lea    (%r12,%rbp,1),%eax
add    $0xfffffffd,%eax
test   $0x7,%al
je     19f0 <state_machine+0x8c0>
shr    $0x8,%r15
jmp    1a06 <state_machine+0x8d6>
add    $0xfffffffffffffffd,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffffd,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x3(%r12,%rbp,1),%r15
cmp    $0x49,%r15b
jne    1a1d <state_machine+0x8ed>
lea    (%r12,%rbp,1),%eax
add    $0xfffffffe,%eax
test   $0x7,%al
je     1a26 <state_machine+0x8f6>
shr    $0x8,%r15
jmp    1a3c <state_machine+0x90c>
add    $0xfffffffffffffffe,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
add    $0xfffffffffffffffe,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x2(%r12,%rbp,1),%r15
cmp    $0x47,%r15b
jne    1a53 <state_machine+0x923>
lea    (%r12,%rbp,1),%eax
add    $0xffffffff,%eax
test   $0x7,%al
je     1a5c <state_machine+0x92c>
shr    $0x8,%r15
jmp    1a72 <state_machine+0x942>
add    $0xffffffffffffffff,%rbp
jmp    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    -0x1(%r12,%rbp,1),%r15
cmp    $0x5f,%r15b
jne    1190 <state_machine+0x60>
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1a8a <state_machine+0x95a>
shr    $0x8,%r15
jmp    1a97 <state_machine+0x967>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%rbp,1),%r15
add    $0x1,%rbp
movzbl %r15b,%edi
call   1030 <isalnum@plt>
test   %rax,%rax
lea    0x552(%rip),%r8
jne    1a7c <state_machine+0x94c>
movzbl %r15b,%eax
cmp    $0x5f,%eax
je     1a7c <state_machine+0x94c>
jmp    1190 <state_machine+0x60>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    $0x22,%r15b
je     1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1af0 <state_machine+0x9c0>
shr    $0x8,%r15
cmp    $0x5c,%r15b
jne    1ac0 <state_machine+0x990>
jmp    1b02 <state_machine+0x9d2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x5c,%r15b
jne    1ac0 <state_machine+0x990>
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1b18 <state_machine+0x9e8>
shr    $0x8,%r15
add    $0x2,%rbp
jmp    1ace <state_machine+0x99e>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
add    $0x2,%rbp
jmp    1ace <state_machine+0x99e>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x27,%r15b
je     1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1b60 <state_machine+0xa30>
shr    $0x8,%r15
cmp    $0x5c,%r15b
jne    1b30 <state_machine+0xa00>
jmp    1b72 <state_machine+0xa42>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x5c,%r15b
jne    1b30 <state_machine+0xa00>
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1b88 <state_machine+0xa58>
shr    $0x8,%r15
add    $0x2,%rbp
jmp    1b3e <state_machine+0xa0e>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
add    $0x2,%rbp
jmp    1b3e <state_machine+0xa0e>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0xa,%r15b
je     1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1bd0 <state_machine+0xaa0>
shr    $0x8,%r15
cmp    $0x5c,%r15b
jne    1ba0 <state_machine+0xa70>
jmp    1be2 <state_machine+0xab2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
cmp    $0x5c,%r15b
jne    1ba0 <state_machine+0xa70>
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1bf8 <state_machine+0xac8>
shr    $0x8,%r15
add    $0x2,%rbp
jmp    1bae <state_machine+0xa7e>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%rax),%r15
add    $0x2,%rbp
jmp    1bae <state_machine+0xa7e>
mov    (%rax),%r15
add    $0x1,%rbp
jmp    1c32 <state_machine+0xb02>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
shr    $0x8,%r15
add    $0x1,%rbp
cmp    $0x2f,%r15b
je     1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rax
cmp    $0x2a,%r15b
jne    1c54 <state_machine+0xb24>
lea    (%r12,%rbp,1),%ecx
test   $0x7,%cl
jne    1c20 <state_machine+0xaf0>
cmp    %r14,%rax
jae    1d18 <state_machine+0xbe8>
mov    (%r12,%rbp,1),%r15
jmp    1c24 <state_machine+0xaf4>
lea    (%r12,%rbp,1),%rax
test   $0x7,%al
je     1c62 <state_machine+0xb32>
shr    $0x8,%r15
jmp    1c0d <state_machine+0xadd>
cmp    %r14,%rax
jb     1c0a <state_machine+0xada>
jmp    1d18 <state_machine+0xbe8>
lea    0x38d(%rip),%r8
jmp    1162 <state_machine+0x32>
lea    (%r12,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffff,%edx
test   $0x7,%cl
je     1c94 <state_machine+0xb64>
shr    $0x8,%r15
jmp    1c9c <state_machine+0xb6c>
cmp    %r14,%rdi
jae    1d18 <state_machine+0xbe8>
mov    (%rdi),%r15
add    $0x1,%rbp
cmp    $0xa,%r15b
je     1162 <state_machine+0x32>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%edx
cmp    $0x22,%r15b
jne    1c89 <state_machine+0xb59>
xor    %edi,%edi
jmp    1d07 <state_machine+0xbd7>
lea    (%r12,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffff,%edx
test   $0x7,%cl
je     1cdb <state_machine+0xbab>
shr    $0x8,%r15
jmp    1ce3 <state_machine+0xbb3>
cmp    %r14,%rdi
jae    1d18 <state_machine+0xbe8>
mov    (%rdi),%r15
add    $0x1,%rbp
cmp    $0xa,%r15b
je     1162 <state_machine+0x32>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%edx
cmp    $0x3e,%r15b
jne    1cd0 <state_machine+0xba0>
mov    $0x1,%edi
call   1040 <handle_include@plt>
lea    0x2ed(%rip),%r8
jmp    1162 <state_machine+0x32>
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 = %1067, %608, %601, %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 %1253
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 = %1243, %1211, %1187, %1163, %1139, %1115, %1091, %1047, %1015, %991, %967, %943, %919, %895, %871, %834, %810, %786, %762, %737, %713, %689, %665, %641, %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 %1048
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %618
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 %739
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %1253
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 %578
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 %1253
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 = trunc i64 %575 to i32
%577 = call i32 @handle_include(i32 0, i8* %569, i32 %576)
br label %10
578: ; preds = %607, %536
%579 = load i64, i64* %7
%580 = lshr i64 %579, 8
store i64 %580, i64* %7
%581 = load i8*, i8** %5
%582 = ptrtoint i8* %581 to i64
%583 = urem i64 %582, 8
%584 = icmp eq i64 %583, 0
br i1 %584, label %585, label %594
585: ; preds = %578
%586 = load i8*, i8** %5
%587 = load i8*, i8** %4
%588 = icmp uge i8* %586, %587
br i1 %588, label %589, label %590
589: ; preds = %585
br label %1253
590: ; preds = %585
%591 = load i8*, i8** %5
%592 = bitcast i8* %591 to i64*
%593 = load i64, i64* %592
store i64 %593, i64* %7
br label %594
594: ; preds = %590, %578
%595 = load i8*, i8** %5
%596 = getelementptr inbounds i8, i8* %595, i32 1
store i8* %596, i8** %5
%597 = load i64, i64* %7
%598 = trunc i64 %597 to i8
%599 = zext i8 %598 to i32
%600 = icmp eq i32 %599, 10
br i1 %600, label %601, label %602
601: ; preds = %594
br label %10
602: ; preds = %594
%603 = load i64, i64* %7
%604 = trunc i64 %603 to i8
%605 = zext i8 %604 to i32
%606 = icmp ne i32 %605, 62
br i1 %606, label %607, label %608
607: ; preds = %602
br label %578
608: ; preds = %602
%609 = load i8*, i8** %6
%610 = load i8*, i8** %5
%611 = load i8*, i8** %6
%612 = ptrtoint i8* %610 to i64
%613 = ptrtoint i8* %611 to i64
%614 = sub i64 %612, %613
%615 = sub nsw i64 %614, 1
%616 = trunc i64 %615 to i32
%617 = call i32 @handle_include(i32 1, i8* %609, i32 %616)
br label %10
618: ; preds = %341
%619 = load i64, i64* %7
%620 = lshr i64 %619, 8
store i64 %620, i64* %7
%621 = load i8*, i8** %5
%622 = ptrtoint i8* %621 to i64
%623 = urem i64 %622, 8
%624 = icmp eq i64 %623, 0
br i1 %624, label %625, label %634
625: ; preds = %618
%626 = load i8*, i8** %5
%627 = load i8*, i8** %4
%628 = icmp uge i8* %626, %627
br i1 %628, label %629, label %630
629: ; preds = %625
br label %1253
630: ; preds = %625
%631 = load i8*, i8** %5
%632 = bitcast i8* %631 to i64*
%633 = load i64, i64* %632
store i64 %633, i64* %7
br label %634
634: ; preds = %630, %618
%635 = load i8*, i8** %5
%636 = getelementptr inbounds i8, i8* %635, i32 1
store i8* %636, i8** %5
%637 = load i64, i64* %7
%638 = trunc i64 %637 to i8
%639 = zext i8 %638 to i32
%640 = icmp ne i32 %639, 101
br i1 %640, label %641, label %642
641: ; preds = %634
br label %29
642: ; preds = %634
%643 = load i64, i64* %7
%644 = lshr i64 %643, 8
store i64 %644, i64* %7
%645 = load i8*, i8** %5
%646 = ptrtoint i8* %645 to i64
%647 = urem i64 %646, 8
%648 = icmp eq i64 %647, 0
br i1 %648, label %649, label %658
649: ; preds = %642
%650 = load i8*, i8** %5
%651 = load i8*, i8** %4
%652 = icmp uge i8* %650, %651
br i1 %652, label %653, label %654
653: ; preds = %649
br label %1253
654: ; preds = %649
%655 = load i8*, i8** %5
%656 = bitcast i8* %655 to i64*
%657 = load i64, i64* %656
store i64 %657, i64* %7
br label %658
658: ; preds = %654, %642
%659 = load i8*, i8** %5
%660 = getelementptr inbounds i8, i8* %659, i32 1
store i8* %660, i8** %5
%661 = load i64, i64* %7
%662 = trunc i64 %661 to i8
%663 = zext i8 %662 to i32
%664 = icmp ne i32 %663, 102
br i1 %664, label %665, label %666
665: ; preds = %658
br label %29
666: ; preds = %658
%667 = load i64, i64* %7
%668 = lshr i64 %667, 8
store i64 %668, i64* %7
%669 = load i8*, i8** %5
%670 = ptrtoint i8* %669 to i64
%671 = urem i64 %670, 8
%672 = icmp eq i64 %671, 0
br i1 %672, label %673, label %682
673: ; preds = %666
%674 = load i8*, i8** %5
%675 = load i8*, i8** %4
%676 = icmp uge i8* %674, %675
br i1 %676, label %677, label %678
677: ; preds = %673
br label %1253
678: ; preds = %673
%679 = load i8*, i8** %5
%680 = bitcast i8* %679 to i64*
%681 = load i64, i64* %680
store i64 %681, i64* %7
br label %682
682: ; preds = %678, %666
%683 = load i8*, i8** %5
%684 = getelementptr inbounds i8, i8* %683, i32 1
store i8* %684, i8** %5
%685 = load i64, i64* %7
%686 = trunc i64 %685 to i8
%687 = zext i8 %686 to i32
%688 = icmp ne i32 %687, 105
br i1 %688, label %689, label %690
689: ; preds = %682
br label %29
690: ; preds = %682
%691 = load i64, i64* %7
%692 = lshr i64 %691, 8
store i64 %692, i64* %7
%693 = load i8*, i8** %5
%694 = ptrtoint i8* %693 to i64
%695 = urem i64 %694, 8
%696 = icmp eq i64 %695, 0
br i1 %696, label %697, label %706
697: ; preds = %690
%698 = load i8*, i8** %5
%699 = load i8*, i8** %4
%700 = icmp uge i8* %698, %699
br i1 %700, label %701, label %702
701: ; preds = %697
br label %1253
702: ; preds = %697
%703 = load i8*, i8** %5
%704 = bitcast i8* %703 to i64*
%705 = load i64, i64* %704
store i64 %705, i64* %7
br label %706
706: ; preds = %702, %690
%707 = load i8*, i8** %5
%708 = getelementptr inbounds i8, i8* %707, i32 1
store i8* %708, i8** %5
%709 = load i64, i64* %7
%710 = trunc i64 %709 to i8
%711 = zext i8 %710 to i32
%712 = icmp ne i32 %711, 110
br i1 %712, label %713, label %714
713: ; preds = %706
br label %29
714: ; preds = %706
%715 = load i64, i64* %7
%716 = lshr i64 %715, 8
store i64 %716, i64* %7
%717 = load i8*, i8** %5
%718 = ptrtoint i8* %717 to i64
%719 = urem i64 %718, 8
%720 = icmp eq i64 %719, 0
br i1 %720, label %721, label %730
721: ; preds = %714
%722 = load i8*, i8** %5
%723 = load i8*, i8** %4
%724 = icmp uge i8* %722, %723
br i1 %724, label %725, label %726
725: ; preds = %721
br label %1253
726: ; preds = %721
%727 = load i8*, i8** %5
%728 = bitcast i8* %727 to i64*
%729 = load i64, i64* %728
store i64 %729, i64* %7
br label %730
730: ; preds = %726, %714
%731 = load i8*, i8** %5
%732 = getelementptr inbounds i8, i8* %731, i32 1
store i8* %732, i8** %5
%733 = load i64, i64* %7
%734 = trunc i64 %733 to i8
%735 = zext i8 %734 to i32
%736 = icmp ne i32 %735, 101
br i1 %736, label %737, label %738
737: ; preds = %730
br label %29
738: ; preds = %730
br label %836
739: ; preds = %347
%740 = load i64, i64* %7
%741 = lshr i64 %740, 8
store i64 %741, i64* %7
%742 = load i8*, i8** %5
%743 = ptrtoint i8* %742 to i64
%744 = urem i64 %743, 8
%745 = icmp eq i64 %744, 0
br i1 %745, label %746, label %755
746: ; preds = %739
%747 = load i8*, i8** %5
%748 = load i8*, i8** %4
%749 = icmp uge i8* %747, %748
br i1 %749, label %750, label %751
750: ; preds = %746
br label %1253
751: ; preds = %746
%752 = load i8*, i8** %5
%753 = bitcast i8* %752 to i64*
%754 = load i64, i64* %753
store i64 %754, i64* %7
br label %755
755: ; preds = %751, %739
%756 = load i8*, i8** %5
%757 = getelementptr inbounds i8, i8* %756, i32 1
store i8* %757, i8** %5
%758 = load i64, i64* %7
%759 = trunc i64 %758 to i8
%760 = zext i8 %759 to i32
%761 = icmp ne i32 %760, 110
br i1 %761, label %762, label %763
762: ; preds = %755
br label %29
763: ; preds = %755
%764 = load i64, i64* %7
%765 = lshr i64 %764, 8
store i64 %765, i64* %7
%766 = load i8*, i8** %5
%767 = ptrtoint i8* %766 to i64
%768 = urem i64 %767, 8
%769 = icmp eq i64 %768, 0
br i1 %769, label %770, label %779
770: ; preds = %763
%771 = load i8*, i8** %5
%772 = load i8*, i8** %4
%773 = icmp uge i8* %771, %772
br i1 %773, label %774, label %775
774: ; preds = %770
br label %1253
775: ; preds = %770
%776 = load i8*, i8** %5
%777 = bitcast i8* %776 to i64*
%778 = load i64, i64* %777
store i64 %778, i64* %7
br label %779
779: ; preds = %775, %763
%780 = load i8*, i8** %5
%781 = getelementptr inbounds i8, i8* %780, i32 1
store i8* %781, i8** %5
%782 = load i64, i64* %7
%783 = trunc i64 %782 to i8
%784 = zext i8 %783 to i32
%785 = icmp ne i32 %784, 100
br i1 %785, label %786, label %787
786: ; preds = %779
br label %29
787: ; preds = %779
%788 = load i64, i64* %7
%789 = lshr i64 %788, 8
store i64 %789, i64* %7
%790 = load i8*, i8** %5
%791 = ptrtoint i8* %790 to i64
%792 = urem i64 %791, 8
%793 = icmp eq i64 %792, 0
br i1 %793, label %794, label %803
794: ; preds = %787
%795 = load i8*, i8** %5
%796 = load i8*, i8** %4
%797 = icmp uge i8* %795, %796
br i1 %797, label %798, label %799
798: ; preds = %794
br label %1253
799: ; preds = %794
%800 = load i8*, i8** %5
%801 = bitcast i8* %800 to i64*
%802 = load i64, i64* %801
store i64 %802, i64* %7
br label %803
803: ; preds = %799, %787
%804 = load i8*, i8** %5
%805 = getelementptr inbounds i8, i8* %804, i32 1
store i8* %805, i8** %5
%806 = load i64, i64* %7
%807 = trunc i64 %806 to i8
%808 = zext i8 %807 to i32
%809 = icmp ne i32 %808, 101
br i1 %809, label %810, label %811
810: ; preds = %803
br label %29
811: ; preds = %803
%812 = load i64, i64* %7
%813 = lshr i64 %812, 8
store i64 %813, i64* %7
%814 = load i8*, i8** %5
%815 = ptrtoint i8* %814 to i64
%816 = urem i64 %815, 8
%817 = icmp eq i64 %816, 0
br i1 %817, label %818, label %827
818: ; preds = %811
%819 = load i8*, i8** %5
%820 = load i8*, i8** %4
%821 = icmp uge i8* %819, %820
br i1 %821, label %822, label %823
822: ; preds = %818
br label %1253
823: ; preds = %818
%824 = load i8*, i8** %5
%825 = bitcast i8* %824 to i64*
%826 = load i64, i64* %825
store i64 %826, i64* %7
br label %827
827: ; preds = %823, %811
%828 = load i8*, i8** %5
%829 = getelementptr inbounds i8, i8* %828, i32 1
store i8* %829, i8** %5
%830 = load i64, i64* %7
%831 = trunc i64 %830 to i8
%832 = zext i8 %831 to i32
%833 = icmp ne i32 %832, 102
br i1 %833, label %834, label %835
834: ; preds = %827
br label %29
835: ; preds = %827
br label %836
836: ; preds = %865, %859, %835, %738
%837 = load i64, i64* %7
%838 = lshr i64 %837, 8
store i64 %838, i64* %7
%839 = load i8*, i8** %5
%840 = ptrtoint i8* %839 to i64
%841 = urem i64 %840, 8
%842 = icmp eq i64 %841, 0
br i1 %842, label %843, label %852
843: ; preds = %836
%844 = load i8*, i8** %5
%845 = load i8*, i8** %4
%846 = icmp uge i8* %844, %845
br i1 %846, label %847, label %848
847: ; preds = %843
br label %1253
848: ; preds = %843
%849 = load i8*, i8** %5
%850 = bitcast i8* %849 to i64*
%851 = load i64, i64* %850
store i64 %851, i64* %7
br label %852
852: ; preds = %848, %836
%853 = load i8*, i8** %5
%854 = getelementptr inbounds i8, i8* %853, i32 1
store i8* %854, i8** %5
%855 = load i64, i64* %7
%856 = trunc i64 %855 to i8
%857 = zext i8 %856 to i32
%858 = icmp eq i32 %857, 32
br i1 %858, label %859, label %860
859: ; preds = %852
br label %836
860: ; preds = %852
%861 = load i64, i64* %7
%862 = trunc i64 %861 to i8
%863 = zext i8 %862 to i32
%864 = icmp eq i32 %863, 9
br i1 %864, label %865, label %866
865: ; preds = %860
br label %836
866: ; preds = %860
%867 = load i64, i64* %7
%868 = trunc i64 %867 to i8
%869 = zext i8 %868 to i32
%870 = icmp ne i32 %869, 67
br i1 %870, label %871, label %872
871: ; preds = %866
br label %29
872: ; preds = %866
%873 = load i64, i64* %7
%874 = lshr i64 %873, 8
store i64 %874, i64* %7
%875 = load i8*, i8** %5
%876 = ptrtoint i8* %875 to i64
%877 = urem i64 %876, 8
%878 = icmp eq i64 %877, 0
br i1 %878, label %879, label %888
879: ; preds = %872
%880 = load i8*, i8** %5
%881 = load i8*, i8** %4
%882 = icmp uge i8* %880, %881
br i1 %882, label %883, label %884
883: ; preds = %879
br label %1253
884: ; preds = %879
%885 = load i8*, i8** %5
%886 = bitcast i8* %885 to i64*
%887 = load i64, i64* %886
store i64 %887, i64* %7
br label %888
888: ; preds = %884, %872
%889 = load i8*, i8** %5
%890 = getelementptr inbounds i8, i8* %889, i32 1
store i8* %890, i8** %5
%891 = load i64, i64* %7
%892 = trunc i64 %891 to i8
%893 = zext i8 %892 to i32
%894 = icmp ne i32 %893, 79
br i1 %894, label %895, label %896
895: ; preds = %888
br label %29
896: ; preds = %888
%897 = load i64, i64* %7
%898 = lshr i64 %897, 8
store i64 %898, i64* %7
%899 = load i8*, i8** %5
%900 = ptrtoint i8* %899 to i64
%901 = urem i64 %900, 8
%902 = icmp eq i64 %901, 0
br i1 %902, label %903, label %912
903: ; preds = %896
%904 = load i8*, i8** %5
%905 = load i8*, i8** %4
%906 = icmp uge i8* %904, %905
br i1 %906, label %907, label %908
907: ; preds = %903
br label %1253
908: ; preds = %903
%909 = load i8*, i8** %5
%910 = bitcast i8* %909 to i64*
%911 = load i64, i64* %910
store i64 %911, i64* %7
br label %912
912: ; preds = %908, %896
%913 = load i8*, i8** %5
%914 = getelementptr inbounds i8, i8* %913, i32 1
store i8* %914, i8** %5
%915 = load i64, i64* %7
%916 = trunc i64 %915 to i8
%917 = zext i8 %916 to i32
%918 = icmp ne i32 %917, 78
br i1 %918, label %919, label %920
919: ; preds = %912
br label %29
920: ; preds = %912
%921 = load i64, i64* %7
%922 = lshr i64 %921, 8
store i64 %922, i64* %7
%923 = load i8*, i8** %5
%924 = ptrtoint i8* %923 to i64
%925 = urem i64 %924, 8
%926 = icmp eq i64 %925, 0
br i1 %926, label %927, label %936
927: ; preds = %920
%928 = load i8*, i8** %5
%929 = load i8*, i8** %4
%930 = icmp uge i8* %928, %929
br i1 %930, label %931, label %932
931: ; preds = %927
br label %1253
932: ; preds = %927
%933 = load i8*, i8** %5
%934 = bitcast i8* %933 to i64*
%935 = load i64, i64* %934
store i64 %935, i64* %7
br label %936
936: ; preds = %932, %920
%937 = load i8*, i8** %5
%938 = getelementptr inbounds i8, i8* %937, i32 1
store i8* %938, i8** %5
%939 = load i64, i64* %7
%940 = trunc i64 %939 to i8
%941 = zext i8 %940 to i32
%942 = icmp ne i32 %941, 70
br i1 %942, label %943, label %944
943: ; preds = %936
br label %29
944: ; preds = %936
%945 = load i64, i64* %7
%946 = lshr i64 %945, 8
store i64 %946, i64* %7
%947 = load i8*, i8** %5
%948 = ptrtoint i8* %947 to i64
%949 = urem i64 %948, 8
%950 = icmp eq i64 %949, 0
br i1 %950, label %951, label %960
951: ; preds = %944
%952 = load i8*, i8** %5
%953 = load i8*, i8** %4
%954 = icmp uge i8* %952, %953
br i1 %954, label %955, label %956
955: ; preds = %951
br label %1253
956: ; preds = %951
%957 = load i8*, i8** %5
%958 = bitcast i8* %957 to i64*
%959 = load i64, i64* %958
store i64 %959, i64* %7
br label %960
960: ; preds = %956, %944
%961 = load i8*, i8** %5
%962 = getelementptr inbounds i8, i8* %961, i32 1
store i8* %962, i8** %5
%963 = load i64, i64* %7
%964 = trunc i64 %963 to i8
%965 = zext i8 %964 to i32
%966 = icmp ne i32 %965, 73
br i1 %966, label %967, label %968
967: ; preds = %960
br label %29
968: ; preds = %960
%969 = load i64, i64* %7
%970 = lshr i64 %969, 8
store i64 %970, i64* %7
%971 = load i8*, i8** %5
%972 = ptrtoint i8* %971 to i64
%973 = urem i64 %972, 8
%974 = icmp eq i64 %973, 0
br i1 %974, label %975, label %984
975: ; preds = %968
%976 = load i8*, i8** %5
%977 = load i8*, i8** %4
%978 = icmp uge i8* %976, %977
br i1 %978, label %979, label %980
979: ; preds = %975
br label %1253
980: ; preds = %975
%981 = load i8*, i8** %5
%982 = bitcast i8* %981 to i64*
%983 = load i64, i64* %982
store i64 %983, i64* %7
br label %984
984: ; preds = %980, %968
%985 = load i8*, i8** %5
%986 = getelementptr inbounds i8, i8* %985, i32 1
store i8* %986, i8** %5
%987 = load i64, i64* %7
%988 = trunc i64 %987 to i8
%989 = zext i8 %988 to i32
%990 = icmp ne i32 %989, 71
br i1 %990, label %991, label %992
991: ; preds = %984
br label %29
992: ; preds = %984
%993 = load i64, i64* %7
%994 = lshr i64 %993, 8
store i64 %994, i64* %7
%995 = load i8*, i8** %5
%996 = ptrtoint i8* %995 to i64
%997 = urem i64 %996, 8
%998 = icmp eq i64 %997, 0
br i1 %998, label %999, label %1008
999: ; preds = %992
%1000 = load i8*, i8** %5
%1001 = load i8*, i8** %4
%1002 = icmp uge i8* %1000, %1001
br i1 %1002, label %1003, label %1004
1003: ; preds = %999
br label %1253
1004: ; preds = %999
%1005 = load i8*, i8** %5
%1006 = bitcast i8* %1005 to i64*
%1007 = load i64, i64* %1006
store i64 %1007, i64* %7
br label %1008
1008: ; preds = %1004, %992
%1009 = load i8*, i8** %5
%1010 = getelementptr inbounds i8, i8* %1009, i32 1
store i8* %1010, i8** %5
%1011 = load i64, i64* %7
%1012 = trunc i64 %1011 to i8
%1013 = zext i8 %1012 to i32
%1014 = icmp ne i32 %1013, 95
br i1 %1014, label %1015, label %1016
1015: ; preds = %1008
br label %29
1016: ; preds = %1008
%1017 = load i8*, i8** %5
store i8* %1017, i8** %6
br label %1018
1018: ; preds = %1046, %1016
%1019 = load i64, i64* %7
%1020 = lshr i64 %1019, 8
store i64 %1020, i64* %7
%1021 = load i8*, i8** %5
%1022 = ptrtoint i8* %1021 to i64
%1023 = urem i64 %1022, 8
%1024 = icmp eq i64 %1023, 0
br i1 %1024, label %1025, label %1034
1025: ; preds = %1018
%1026 = load i8*, i8** %5
%1027 = load i8*, i8** %4
%1028 = icmp uge i8* %1026, %1027
br i1 %1028, label %1029, label %1030
1029: ; preds = %1025
br label %1253
1030: ; preds = %1025
%1031 = load i8*, i8** %5
%1032 = bitcast i8* %1031 to i64*
%1033 = load i64, i64* %1032
store i64 %1033, i64* %7
br label %1034
1034: ; preds = %1030, %1018
%1035 = load i8*, i8** %5
%1036 = getelementptr inbounds i8, i8* %1035, i32 1
store i8* %1036, i8** %5
%1037 = load i64, i64* %7
%1038 = trunc i64 %1037 to i8
%1039 = call i64 @isalnum(i8 zeroext %1038)
%1040 = icmp ne i64 %1039, 0
br i1 %1040, label %1046, label %1041
1041: ; preds = %1034
%1042 = load i64, i64* %7
%1043 = trunc i64 %1042 to i8
%1044 = zext i8 %1043 to i32
%1045 = icmp eq i32 %1044, 95
br i1 %1045, label %1046, label %1047
1046: ; preds = %1041, %1034
br label %1018
1047: ; preds = %1041
br label %29
1048: ; preds = %70
%1049 = load i8*, i8** %5
%1050 = load i8*, i8** %3
%1051 = getelementptr inbounds i8, i8* %1050, i64 2
%1052 = icmp uge i8* %1049, %1051
br i1 %1052, label %1053, label %1068
1053: ; preds = %1048
%1054 = load i8*, i8** %5
%1055 = getelementptr inbounds i8, i8* %1054, i64 -2
%1056 = load i8, i8* %1055
%1057 = sext i8 %1056 to i32
%1058 = trunc i32 %1057 to i8
%1059 = call i64 @isalnum(i8 zeroext %1058)
%1060 = icmp ne i64 %1059, 0
br i1 %1060, label %1067, label %1061
1061: ; preds = %1053
%1062 = load i8*, i8** %5
%1063 = getelementptr inbounds i8, i8* %1062, i64 -2
%1064 = load i8, i8* %1063
%1065 = sext i8 %1064 to i32
%1066 = icmp eq i32 %1065, 95
br i1 %1066, label %1067, label %1068
1067: ; preds = %1061, %1053
br label %10
1068: ; preds = %1061, %1048
%1069 = load i64, i64* %7
%1070 = lshr i64 %1069, 8
store i64 %1070, i64* %7
%1071 = load i8*, i8** %5
%1072 = ptrtoint i8* %1071 to i64
%1073 = urem i64 %1072, 8
%1074 = icmp eq i64 %1073, 0
br i1 %1074, label %1075, label %1084
1075: ; preds = %1068
%1076 = load i8*, i8** %5
%1077 = load i8*, i8** %4
%1078 = icmp uge i8* %1076, %1077
br i1 %1078, label %1079, label %1080
1079: ; preds = %1075
br label %1253
1080: ; preds = %1075
%1081 = load i8*, i8** %5
%1082 = bitcast i8* %1081 to i64*
%1083 = load i64, i64* %1082
store i64 %1083, i64* %7
br label %1084
1084: ; preds = %1080, %1068
%1085 = load i8*, i8** %5
%1086 = getelementptr inbounds i8, i8* %1085, i32 1
store i8* %1086, i8** %5
%1087 = load i64, i64* %7
%1088 = trunc i64 %1087 to i8
%1089 = zext i8 %1088 to i32
%1090 = icmp ne i32 %1089, 79
br i1 %1090, label %1091, label %1092
1091: ; preds = %1084
br label %29
1092: ; preds = %1084
%1093 = load i64, i64* %7
%1094 = lshr i64 %1093, 8
store i64 %1094, i64* %7
%1095 = load i8*, i8** %5
%1096 = ptrtoint i8* %1095 to i64
%1097 = urem i64 %1096, 8
%1098 = icmp eq i64 %1097, 0
br i1 %1098, label %1099, label %1108
1099: ; preds = %1092
%1100 = load i8*, i8** %5
%1101 = load i8*, i8** %4
%1102 = icmp uge i8* %1100, %1101
br i1 %1102, label %1103, label %1104
1103: ; preds = %1099
br label %1253
1104: ; preds = %1099
%1105 = load i8*, i8** %5
%1106 = bitcast i8* %1105 to i64*
%1107 = load i64, i64* %1106
store i64 %1107, i64* %7
br label %1108
1108: ; preds = %1104, %1092
%1109 = load i8*, i8** %5
%1110 = getelementptr inbounds i8, i8* %1109, i32 1
store i8* %1110, i8** %5
%1111 = load i64, i64* %7
%1112 = trunc i64 %1111 to i8
%1113 = zext i8 %1112 to i32
%1114 = icmp ne i32 %1113, 78
br i1 %1114, label %1115, label %1116
1115: ; preds = %1108
br label %29
1116: ; preds = %1108
%1117 = load i64, i64* %7
%1118 = lshr i64 %1117, 8
store i64 %1118, i64* %7
%1119 = load i8*, i8** %5
%1120 = ptrtoint i8* %1119 to i64
%1121 = urem i64 %1120, 8
%1122 = icmp eq i64 %1121, 0
br i1 %1122, label %1123, label %1132
1123: ; preds = %1116
%1124 = load i8*, i8** %5
%1125 = load i8*, i8** %4
%1126 = icmp uge i8* %1124, %1125
br i1 %1126, label %1127, label %1128
1127: ; preds = %1123
br label %1253
1128: ; preds = %1123
%1129 = load i8*, i8** %5
%1130 = bitcast i8* %1129 to i64*
%1131 = load i64, i64* %1130
store i64 %1131, i64* %7
br label %1132
1132: ; preds = %1128, %1116
%1133 = load i8*, i8** %5
%1134 = getelementptr inbounds i8, i8* %1133, i32 1
store i8* %1134, i8** %5
%1135 = load i64, i64* %7
%1136 = trunc i64 %1135 to i8
%1137 = zext i8 %1136 to i32
%1138 = icmp ne i32 %1137, 70
br i1 %1138, label %1139, label %1140
1139: ; preds = %1132
br label %29
1140: ; preds = %1132
%1141 = load i64, i64* %7
%1142 = lshr i64 %1141, 8
store i64 %1142, i64* %7
%1143 = load i8*, i8** %5
%1144 = ptrtoint i8* %1143 to i64
%1145 = urem i64 %1144, 8
%1146 = icmp eq i64 %1145, 0
br i1 %1146, label %1147, label %1156
1147: ; preds = %1140
%1148 = load i8*, i8** %5
%1149 = load i8*, i8** %4
%1150 = icmp uge i8* %1148, %1149
br i1 %1150, label %1151, label %1152
1151: ; preds = %1147
br label %1253
1152: ; preds = %1147
%1153 = load i8*, i8** %5
%1154 = bitcast i8* %1153 to i64*
%1155 = load i64, i64* %1154
store i64 %1155, i64* %7
br label %1156
1156: ; preds = %1152, %1140
%1157 = load i8*, i8** %5
%1158 = getelementptr inbounds i8, i8* %1157, i32 1
store i8* %1158, i8** %5
%1159 = load i64, i64* %7
%1160 = trunc i64 %1159 to i8
%1161 = zext i8 %1160 to i32
%1162 = icmp ne i32 %1161, 73
br i1 %1162, label %1163, label %1164
1163: ; preds = %1156
br label %29
1164: ; preds = %1156
%1165 = load i64, i64* %7
%1166 = lshr i64 %1165, 8
store i64 %1166, i64* %7
%1167 = load i8*, i8** %5
%1168 = ptrtoint i8* %1167 to i64
%1169 = urem i64 %1168, 8
%1170 = icmp eq i64 %1169, 0
br i1 %1170, label %1171, label %1180
1171: ; preds = %1164
%1172 = load i8*, i8** %5
%1173 = load i8*, i8** %4
%1174 = icmp uge i8* %1172, %1173
br i1 %1174, label %1175, label %1176
1175: ; preds = %1171
br label %1253
1176: ; preds = %1171
%1177 = load i8*, i8** %5
%1178 = bitcast i8* %1177 to i64*
%1179 = load i64, i64* %1178
store i64 %1179, i64* %7
br label %1180
1180: ; preds = %1176, %1164
%1181 = load i8*, i8** %5
%1182 = getelementptr inbounds i8, i8* %1181, i32 1
store i8* %1182, i8** %5
%1183 = load i64, i64* %7
%1184 = trunc i64 %1183 to i8
%1185 = zext i8 %1184 to i32
%1186 = icmp ne i32 %1185, 71
br i1 %1186, label %1187, label %1188
1187: ; preds = %1180
br label %29
1188: ; preds = %1180
%1189 = load i64, i64* %7
%1190 = lshr i64 %1189, 8
store i64 %1190, i64* %7
%1191 = load i8*, i8** %5
%1192 = ptrtoint i8* %1191 to i64
%1193 = urem i64 %1192, 8
%1194 = icmp eq i64 %1193, 0
br i1 %1194, label %1195, label %1204
1195: ; preds = %1188
%1196 = load i8*, i8** %5
%1197 = load i8*, i8** %4
%1198 = icmp uge i8* %1196, %1197
br i1 %1198, label %1199, label %1200
1199: ; preds = %1195
br label %1253
1200: ; preds = %1195
%1201 = load i8*, i8** %5
%1202 = bitcast i8* %1201 to i64*
%1203 = load i64, i64* %1202
store i64 %1203, i64* %7
br label %1204
1204: ; preds = %1200, %1188
%1205 = load i8*, i8** %5
%1206 = getelementptr inbounds i8, i8* %1205, i32 1
store i8* %1206, i8** %5
%1207 = load i64, i64* %7
%1208 = trunc i64 %1207 to i8
%1209 = zext i8 %1208 to i32
%1210 = icmp ne i32 %1209, 95
br i1 %1210, label %1211, label %1212
1211: ; preds = %1204
br label %29
1212: ; preds = %1204
%1213 = load i8*, i8** %5
store i8* %1213, i8** %6
br label %1214
1214: ; preds = %1242, %1212
%1215 = load i64, i64* %7
%1216 = lshr i64 %1215, 8
store i64 %1216, i64* %7
%1217 = load i8*, i8** %5
%1218 = ptrtoint i8* %1217 to i64
%1219 = urem i64 %1218, 8
%1220 = icmp eq i64 %1219, 0
br i1 %1220, label %1221, label %1230
1221: ; preds = %1214
%1222 = load i8*, i8** %5
%1223 = load i8*, i8** %4
%1224 = icmp uge i8* %1222, %1223
br i1 %1224, label %1225, label %1226
1225: ; preds = %1221
br label %1253
1226: ; preds = %1221
%1227 = load i8*, i8** %5
%1228 = bitcast i8* %1227 to i64*
%1229 = load i64, i64* %1228
store i64 %1229, i64* %7
br label %1230
1230: ; preds = %1226, %1214
%1231 = load i8*, i8** %5
%1232 = getelementptr inbounds i8, i8* %1231, i32 1
store i8* %1232, i8** %5
%1233 = load i64, i64* %7
%1234 = trunc i64 %1233 to i8
%1235 = call i64 @isalnum(i8 zeroext %1234)
%1236 = icmp ne i64 %1235, 0
br i1 %1236, label %1242, label %1237
1237: ; preds = %1230
%1238 = load i64, i64* %7
%1239 = trunc i64 %1238 to i8
%1240 = zext i8 %1239 to i32
%1241 = icmp eq i32 %1240, 95
br i1 %1241, label %1242, label %1243
1242: ; preds = %1237, %1230
br label %1214
1243: ; preds = %1237
%1244 = load i8*, i8** %6
%1245 = load i8*, i8** %5
%1246 = load i8*, i8** %6
%1247 = ptrtoint i8* %1245 to i64
%1248 = ptrtoint i8* %1246 to i64
%1249 = sub i64 %1247, %1248
%1250 = sub nsw i64 %1249, 1
%1251 = trunc i64 %1250 to i32
%1252 = call i32 @use_config(i8* %1244, i32 %1251)
br label %29
1253: ; preds = %1225, %1199, %1175, %1151, %1127, %1103, %1079, %1029, %1003, %979, %955, %931, %907, %883, %847, %822, %798, %774, %750, %725, %701, %677, %653, %629, %589, %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 %796
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 = %26, %789, %660, %655, %358, %331, %163, %129, %44, %111, %16, %335, %362
%24 = phi i64 [ %333, %335 ], [ %360, %362 ], [ %18, %16 ], [ %113, %111 ], [ %46, %44 ], [ %131, %129 ], [ %165, %163 ], [ %333, %331 ], [ %360, %358 ], [ %790, %789 ], [ %28, %26 ], [ %28, %660 ], [ %28, %655 ]
%25 = phi i64 [ %332, %335 ], [ %359, %362 ], [ %17, %16 ], [ %112, %111 ], [ %45, %44 ], [ %130, %129 ], [ %164, %163 ], [ %332, %331 ], [ %359, %358 ], [ %791, %789 ], [ %27, %26 ], [ %27, %660 ], [ %27, %655 ]
br label %3
26: ; preds = %16, %789
%27 = phi i64 [ %791, %789 ], [ %17, %16 ]
%28 = phi i64 [ %790, %789 ], [ %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 %653
]
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 %796
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 %796
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 %796
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 %789 [
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 %796
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 %796
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 %796
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 %796
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 %796
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 %796
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 %796
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 %789 [
i8 32, label %201
i8 9, label %201
i8 105, label %202
i8 100, label %370
i8 117, label %450
]
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 %796
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 %789
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 %796
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 %789
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 %796
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 %789
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 %796
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 %789
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 %796
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 %789
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 %796
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 %789
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 %796
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 %789 [
i8 32, label %315
i8 9, label %315
i8 34, label %316
i8 60, label %343
]
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 %796
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 = trunc i64 %340 to i32
%342 = tail call i32 @handle_include(i32 0, i8* %317, i32 %341)
br label %23
343: ; preds = %311
%344 = getelementptr inbounds i8, i8* %0, i64 %313
br label %345
345: ; preds = %343, %358
%346 = phi i64 [ %360, %358 ], [ %313, %343 ]
%347 = phi i64 [ %359, %358 ], [ %312, %343 ]
%348 = getelementptr inbounds i8, i8* %0, i64 %346
%349 = lshr i64 %347, 8
%350 = ptrtoint i8* %348 to i64
%351 = and i64 %350, 7
%352 = icmp eq i64 %351, 0
br i1 %352, label %353, label %358
353: ; preds = %345
%354 = icmp ult i8* %348, %1
br i1 %354, label %355, label %796
355: ; preds = %353
%356 = bitcast i8* %348 to i64*
%357 = load i64, i64* %356
br label %358
358: ; preds = %355, %345
%359 = phi i64 [ %357, %355 ], [ %349, %345 ]
%360 = add nsw i64 %346, 1
%361 = trunc i64 %359 to i8
switch i8 %361, label %345 [
i8 10, label %23
i8 62, label %362
]
362: ; preds = %358
%363 = getelementptr inbounds i8, i8* %0, i64 %360
%364 = ptrtoint i8* %363 to i64
%365 = ptrtoint i8* %344 to i64
%366 = xor i64 %365, -1
%367 = add i64 %364, %366
%368 = trunc i64 %367 to i32
%369 = tail call i32 @handle_include(i32 1, i8* %344, i32 %368)
br label %23
370: ; preds = %197
%371 = getelementptr inbounds i8, i8* %0, i64 %199
%372 = lshr i64 %198, 8
%373 = ptrtoint i8* %371 to i64
%374 = and i64 %373, 7
%375 = icmp eq i64 %374, 0
br i1 %375, label %376, label %381
376: ; preds = %370
%377 = icmp ult i8* %371, %1
br i1 %377, label %378, label %796
378: ; preds = %376
%379 = bitcast i8* %371 to i64*
%380 = load i64, i64* %379
br label %381
381: ; preds = %378, %370
%382 = phi i64 [ %380, %378 ], [ %372, %370 ]
%383 = add nsw i64 %185, 2
%384 = getelementptr inbounds i8, i8* %0, i64 %383
%385 = and i64 %382, 255
%386 = icmp eq i64 %385, 101
br i1 %386, label %387, label %789
387: ; preds = %381
%388 = lshr i64 %382, 8
%389 = ptrtoint i8* %384 to i64
%390 = and i64 %389, 7
%391 = icmp eq i64 %390, 0
br i1 %391, label %392, label %397
392: ; preds = %387
%393 = icmp ult i8* %384, %1
br i1 %393, label %394, label %796
394: ; preds = %392
%395 = bitcast i8* %384 to i64*
%396 = load i64, i64* %395
br label %397
397: ; preds = %394, %387
%398 = phi i64 [ %396, %394 ], [ %388, %387 ]
%399 = add nsw i64 %185, 3
%400 = getelementptr inbounds i8, i8* %0, i64 %399
%401 = and i64 %398, 255
%402 = icmp eq i64 %401, 102
br i1 %402, label %403, label %789
403: ; preds = %397
%404 = lshr i64 %398, 8
%405 = ptrtoint i8* %400 to i64
%406 = and i64 %405, 7
%407 = icmp eq i64 %406, 0
br i1 %407, label %408, label %413
408: ; preds = %403
%409 = icmp ult i8* %400, %1
br i1 %409, label %410, label %796
410: ; preds = %408
%411 = bitcast i8* %400 to i64*
%412 = load i64, i64* %411
br label %413
413: ; preds = %410, %403
%414 = phi i64 [ %412, %410 ], [ %404, %403 ]
%415 = add nsw i64 %185, 4
%416 = getelementptr inbounds i8, i8* %0, i64 %415
%417 = and i64 %414, 255
%418 = icmp eq i64 %417, 105
br i1 %418, label %419, label %789
419: ; preds = %413
%420 = lshr i64 %414, 8
%421 = ptrtoint i8* %416 to i64
%422 = and i64 %421, 7
%423 = icmp eq i64 %422, 0
br i1 %423, label %424, label %429
424: ; preds = %419
%425 = icmp ult i8* %416, %1
br i1 %425, label %426, label %796
426: ; preds = %424
%427 = bitcast i8* %416 to i64*
%428 = load i64, i64* %427
br label %429
429: ; preds = %426, %419
%430 = phi i64 [ %428, %426 ], [ %420, %419 ]
%431 = add nsw i64 %185, 5
%432 = getelementptr inbounds i8, i8* %0, i64 %431
%433 = and i64 %430, 255
%434 = icmp eq i64 %433, 110
br i1 %434, label %435, label %789
435: ; preds = %429
%436 = lshr i64 %430, 8
%437 = ptrtoint i8* %432 to i64
%438 = and i64 %437, 7
%439 = icmp eq i64 %438, 0
br i1 %439, label %440, label %445
440: ; preds = %435
%441 = icmp ult i8* %432, %1
br i1 %441, label %442, label %796
442: ; preds = %440
%443 = bitcast i8* %432 to i64*
%444 = load i64, i64* %443
br label %445
445: ; preds = %442, %435
%446 = phi i64 [ %444, %442 ], [ %436, %435 ]
%447 = add nsw i64 %185, 6
%448 = and i64 %446, 255
%449 = icmp eq i64 %448, 101
br i1 %449, label %514, label %789
450: ; preds = %197
%451 = getelementptr inbounds i8, i8* %0, i64 %199
%452 = lshr i64 %198, 8
%453 = ptrtoint i8* %451 to i64
%454 = and i64 %453, 7
%455 = icmp eq i64 %454, 0
br i1 %455, label %456, label %461
456: ; preds = %450
%457 = icmp ult i8* %451, %1
br i1 %457, label %458, label %796
458: ; preds = %456
%459 = bitcast i8* %451 to i64*
%460 = load i64, i64* %459
br label %461
461: ; preds = %458, %450
%462 = phi i64 [ %460, %458 ], [ %452, %450 ]
%463 = add nsw i64 %185, 2
%464 = getelementptr inbounds i8, i8* %0, i64 %463
%465 = and i64 %462, 255
%466 = icmp eq i64 %465, 110
br i1 %466, label %467, label %789
467: ; preds = %461
%468 = lshr i64 %462, 8
%469 = ptrtoint i8* %464 to i64
%470 = and i64 %469, 7
%471 = icmp eq i64 %470, 0
br i1 %471, label %472, label %477
472: ; preds = %467
%473 = icmp ult i8* %464, %1
br i1 %473, label %474, label %796
474: ; preds = %472
%475 = bitcast i8* %464 to i64*
%476 = load i64, i64* %475
br label %477
477: ; preds = %474, %467
%478 = phi i64 [ %476, %474 ], [ %468, %467 ]
%479 = add nsw i64 %185, 3
%480 = getelementptr inbounds i8, i8* %0, i64 %479
%481 = and i64 %478, 255
%482 = icmp eq i64 %481, 100
br i1 %482, label %483, label %789
483: ; preds = %477
%484 = lshr i64 %478, 8
%485 = ptrtoint i8* %480 to i64
%486 = and i64 %485, 7
%487 = icmp eq i64 %486, 0
br i1 %487, label %488, label %493
488: ; preds = %483
%489 = icmp ult i8* %480, %1
br i1 %489, label %490, label %796
490: ; preds = %488
%491 = bitcast i8* %480 to i64*
%492 = load i64, i64* %491
br label %493
493: ; preds = %490, %483
%494 = phi i64 [ %492, %490 ], [ %484, %483 ]
%495 = add nsw i64 %185, 4
%496 = getelementptr inbounds i8, i8* %0, i64 %495
%497 = and i64 %494, 255
%498 = icmp eq i64 %497, 101
br i1 %498, label %499, label %789
499: ; preds = %493
%500 = lshr i64 %494, 8
%501 = ptrtoint i8* %496 to i64
%502 = and i64 %501, 7
%503 = icmp eq i64 %502, 0
br i1 %503, label %504, label %509
504: ; preds = %499
%505 = icmp ult i8* %496, %1
br i1 %505, label %506, label %796
506: ; preds = %504
%507 = bitcast i8* %496 to i64*
%508 = load i64, i64* %507
br label %509
509: ; preds = %506, %499
%510 = phi i64 [ %508, %506 ], [ %500, %499 ]
%511 = add nsw i64 %185, 5
%512 = and i64 %510, 255
%513 = icmp eq i64 %512, 102
br i1 %513, label %514, label %789
514: ; preds = %445, %509
%515 = phi i64 [ %447, %445 ], [ %511, %509 ]
%516 = phi i64 [ %446, %445 ], [ %510, %509 ]
br label %517
517: ; preds = %534, %514
%518 = phi i64 [ %515, %514 ], [ %532, %534 ]
%519 = phi i64 [ %516, %514 ], [ %531, %534 ]
%520 = getelementptr inbounds i8, i8* %0, i64 %518
%521 = lshr i64 %519, 8
%522 = ptrtoint i8* %520 to i64
%523 = and i64 %522, 7
%524 = icmp eq i64 %523, 0
br i1 %524, label %525, label %530
525: ; preds = %517
%526 = icmp ult i8* %520, %1
br i1 %526, label %527, label %796
527: ; preds = %525
%528 = bitcast i8* %520 to i64*
%529 = load i64, i64* %528
br label %530
530: ; preds = %527, %517
%531 = phi i64 [ %529, %527 ], [ %521, %517 ]
%532 = add nsw i64 %518, 1
%533 = trunc i64 %531 to i8
switch i8 %533, label %789 [
i8 32, label %534
i8 9, label %534
i8 67, label %535
]
534: ; preds = %530, %530
br label %517
535: ; preds = %530
%536 = getelementptr inbounds i8, i8* %0, i64 %532
%537 = lshr i64 %531, 8
%538 = ptrtoint i8* %536 to i64
%539 = and i64 %538, 7
%540 = icmp eq i64 %539, 0
br i1 %540, label %541, label %546
541: ; preds = %535
%542 = icmp ult i8* %536, %1
br i1 %542, label %543, label %796
543: ; preds = %541
%544 = bitcast i8* %536 to i64*
%545 = load i64, i64* %544
br label %546
546: ; preds = %543, %535
%547 = phi i64 [ %545, %543 ], [ %537, %535 ]
%548 = add nsw i64 %518, 2
%549 = getelementptr inbounds i8, i8* %0, i64 %548
%550 = and i64 %547, 255
%551 = icmp eq i64 %550, 79
br i1 %551, label %552, label %789
552: ; preds = %546
%553 = lshr i64 %547, 8
%554 = ptrtoint i8* %549 to i64
%555 = and i64 %554, 7
%556 = icmp eq i64 %555, 0
br i1 %556, label %557, label %562
557: ; preds = %552
%558 = icmp ult i8* %549, %1
br i1 %558, label %559, label %796
559: ; preds = %557
%560 = bitcast i8* %549 to i64*
%561 = load i64, i64* %560
br label %562
562: ; preds = %559, %552
%563 = phi i64 [ %561, %559 ], [ %553, %552 ]
%564 = add nsw i64 %518, 3
%565 = getelementptr inbounds i8, i8* %0, i64 %564
%566 = and i64 %563, 255
%567 = icmp eq i64 %566, 78
br i1 %567, label %568, label %789
568: ; preds = %562
%569 = lshr i64 %563, 8
%570 = ptrtoint i8* %565 to i64
%571 = and i64 %570, 7
%572 = icmp eq i64 %571, 0
br i1 %572, label %573, label %578
573: ; preds = %568
%574 = icmp ult i8* %565, %1
br i1 %574, label %575, label %796
575: ; preds = %573
%576 = bitcast i8* %565 to i64*
%577 = load i64, i64* %576
br label %578
578: ; preds = %575, %568
%579 = phi i64 [ %577, %575 ], [ %569, %568 ]
%580 = add nsw i64 %518, 4
%581 = getelementptr inbounds i8, i8* %0, i64 %580
%582 = and i64 %579, 255
%583 = icmp eq i64 %582, 70
br i1 %583, label %584, label %789
584: ; preds = %578
%585 = lshr i64 %579, 8
%586 = ptrtoint i8* %581 to i64
%587 = and i64 %586, 7
%588 = icmp eq i64 %587, 0
br i1 %588, label %589, label %594
589: ; preds = %584
%590 = icmp ult i8* %581, %1
br i1 %590, label %591, label %796
591: ; preds = %589
%592 = bitcast i8* %581 to i64*
%593 = load i64, i64* %592
br label %594
594: ; preds = %591, %584
%595 = phi i64 [ %593, %591 ], [ %585, %584 ]
%596 = add nsw i64 %518, 5
%597 = getelementptr inbounds i8, i8* %0, i64 %596
%598 = and i64 %595, 255
%599 = icmp eq i64 %598, 73
br i1 %599, label %600, label %789
600: ; preds = %594
%601 = lshr i64 %595, 8
%602 = ptrtoint i8* %597 to i64
%603 = and i64 %602, 7
%604 = icmp eq i64 %603, 0
br i1 %604, label %605, label %610
605: ; preds = %600
%606 = icmp ult i8* %597, %1
br i1 %606, label %607, label %796
607: ; preds = %605
%608 = bitcast i8* %597 to i64*
%609 = load i64, i64* %608
br label %610
610: ; preds = %607, %600
%611 = phi i64 [ %609, %607 ], [ %601, %600 ]
%612 = add nsw i64 %518, 6
%613 = getelementptr inbounds i8, i8* %0, i64 %612
%614 = and i64 %611, 255
%615 = icmp eq i64 %614, 71
br i1 %615, label %616, label %789
616: ; preds = %610
%617 = lshr i64 %611, 8
%618 = ptrtoint i8* %613 to i64
%619 = and i64 %618, 7
%620 = icmp eq i64 %619, 0
br i1 %620, label %621, label %626
621: ; preds = %616
%622 = icmp ult i8* %613, %1
br i1 %622, label %623, label %796
623: ; preds = %621
%624 = bitcast i8* %613 to i64*
%625 = load i64, i64* %624
br label %626
626: ; preds = %623, %616
%627 = phi i64 [ %625, %623 ], [ %617, %616 ]
%628 = add nsw i64 %518, 7
%629 = and i64 %627, 255
%630 = icmp eq i64 %629, 95
br i1 %630, label %631, label %789
631: ; preds = %626, %644
%632 = phi i64 [ %646, %644 ], [ %628, %626 ]
%633 = phi i64 [ %645, %644 ], [ %627, %626 ]
%634 = getelementptr inbounds i8, i8* %0, i64 %632
%635 = lshr i64 %633, 8
%636 = ptrtoint i8* %634 to i64
%637 = and i64 %636, 7
%638 = icmp eq i64 %637, 0
br i1 %638, label %639, label %644
639: ; preds = %631
%640 = icmp ult i8* %634, %1
br i1 %640, label %641, label %796
641: ; preds = %639
%642 = bitcast i8* %634 to i64*
%643 = load i64, i64* %642
br label %644
644: ; preds = %641, %631
%645 = phi i64 [ %643, %641 ], [ %635, %631 ]
%646 = add nsw i64 %632, 1
%647 = trunc i64 %645 to i8
%648 = tail call i64 @isalnum(i8 zeroext %647)
%649 = icmp ne i64 %648, 0
%650 = and i64 %645, 255
%651 = icmp eq i64 %650, 95
%652 = select i1 %649, i1 true, i1 %651
br i1 %652, label %631, label %789
653: ; preds = %26
%654 = icmp slt i64 %28, 2
br i1 %654, label %663, label %655
655: ; preds = %653
%656 = getelementptr inbounds i8, i8* %29, i64 -2
%657 = load i8, i8* %656
%658 = tail call i64 @isalnum(i8 zeroext %657)
%659 = icmp eq i64 %658, 0
br i1 %659, label %660, label %23
660: ; preds = %655
%661 = load i8, i8* %656
%662 = icmp eq i8 %661, 95
br i1 %662, label %23, label %663
663: ; preds = %660, %653
%664 = lshr i64 %27, 8
%665 = ptrtoint i8* %29 to i64
%666 = and i64 %665, 7
%667 = icmp eq i64 %666, 0
br i1 %667, label %668, label %673
668: ; preds = %663
%669 = icmp ult i8* %29, %1
br i1 %669, label %670, label %796
670: ; preds = %668
%671 = bitcast i8* %29 to i64*
%672 = load i64, i64* %671
br label %673
673: ; preds = %670, %663
%674 = phi i64 [ %672, %670 ], [ %664, %663 ]
%675 = add nsw i64 %28, 1
%676 = getelementptr inbounds i8, i8* %0, i64 %675
%677 = and i64 %674, 255
%678 = icmp eq i64 %677, 79
br i1 %678, label %679, label %789
679: ; preds = %673
%680 = lshr i64 %674, 8
%681 = ptrtoint i8* %676 to i64
%682 = and i64 %681, 7
%683 = icmp eq i64 %682, 0
br i1 %683, label %684, label %689
684: ; preds = %679
%685 = icmp ult i8* %676, %1
br i1 %685, label %686, label %796
686: ; preds = %684
%687 = bitcast i8* %676 to i64*
%688 = load i64, i64* %687
br label %689
689: ; preds = %686, %679
%690 = phi i64 [ %688, %686 ], [ %680, %679 ]
%691 = add nsw i64 %28, 2
%692 = getelementptr inbounds i8, i8* %0, i64 %691
%693 = and i64 %690, 255
%694 = icmp eq i64 %693, 78
br i1 %694, label %695, label %789
695: ; preds = %689
%696 = lshr i64 %690, 8
%697 = ptrtoint i8* %692 to i64
%698 = and i64 %697, 7
%699 = icmp eq i64 %698, 0
br i1 %699, label %700, label %705
700: ; preds = %695
%701 = icmp ult i8* %692, %1
br i1 %701, label %702, label %796
702: ; preds = %700
%703 = bitcast i8* %692 to i64*
%704 = load i64, i64* %703
br label %705
705: ; preds = %702, %695
%706 = phi i64 [ %704, %702 ], [ %696, %695 ]
%707 = add nsw i64 %28, 3
%708 = getelementptr inbounds i8, i8* %0, i64 %707
%709 = and i64 %706, 255
%710 = icmp eq i64 %709, 70
br i1 %710, label %711, label %789
711: ; preds = %705
%712 = lshr i64 %706, 8
%713 = ptrtoint i8* %708 to i64
%714 = and i64 %713, 7
%715 = icmp eq i64 %714, 0
br i1 %715, label %716, label %721
716: ; preds = %711
%717 = icmp ult i8* %708, %1
br i1 %717, label %718, label %796
718: ; preds = %716
%719 = bitcast i8* %708 to i64*
%720 = load i64, i64* %719
br label %721
721: ; preds = %718, %711
%722 = phi i64 [ %720, %718 ], [ %712, %711 ]
%723 = add nsw i64 %28, 4
%724 = getelementptr inbounds i8, i8* %0, i64 %723
%725 = and i64 %722, 255
%726 = icmp eq i64 %725, 73
br i1 %726, label %727, label %789
727: ; preds = %721
%728 = lshr i64 %722, 8
%729 = ptrtoint i8* %724 to i64
%730 = and i64 %729, 7
%731 = icmp eq i64 %730, 0
br i1 %731, label %732, label %737
732: ; preds = %727
%733 = icmp ult i8* %724, %1
br i1 %733, label %734, label %796
734: ; preds = %732
%735 = bitcast i8* %724 to i64*
%736 = load i64, i64* %735
br label %737
737: ; preds = %734, %727
%738 = phi i64 [ %736, %734 ], [ %728, %727 ]
%739 = add nsw i64 %28, 5
%740 = getelementptr inbounds i8, i8* %0, i64 %739
%741 = and i64 %738, 255
%742 = icmp eq i64 %741, 71
br i1 %742, label %743, label %789
743: ; preds = %737
%744 = lshr i64 %738, 8
%745 = ptrtoint i8* %740 to i64
%746 = and i64 %745, 7
%747 = icmp eq i64 %746, 0
br i1 %747, label %748, label %753
748: ; preds = %743
%749 = icmp ult i8* %740, %1
br i1 %749, label %750, label %796
750: ; preds = %748
%751 = bitcast i8* %740 to i64*
%752 = load i64, i64* %751
br label %753
753: ; preds = %750, %743
%754 = phi i64 [ %752, %750 ], [ %744, %743 ]
%755 = add nsw i64 %28, 6
%756 = getelementptr inbounds i8, i8* %0, i64 %755
%757 = and i64 %754, 255
%758 = icmp eq i64 %757, 95
br i1 %758, label %759, label %789
759: ; preds = %753, %772
%760 = phi i64 [ %774, %772 ], [ %755, %753 ]
%761 = phi i64 [ %773, %772 ], [ %754, %753 ]
%762 = getelementptr inbounds i8, i8* %0, i64 %760
%763 = lshr i64 %761, 8
%764 = ptrtoint i8* %762 to i64
%765 = and i64 %764, 7
%766 = icmp eq i64 %765, 0
br i1 %766, label %767, label %772
767: ; preds = %759
%768 = icmp ult i8* %762, %1
br i1 %768, label %769, label %796
769: ; preds = %767
%770 = bitcast i8* %762 to i64*
%771 = load i64, i64* %770
br label %772
772: ; preds = %769, %759
%773 = phi i64 [ %771, %769 ], [ %763, %759 ]
%774 = add nsw i64 %760, 1
%775 = trunc i64 %773 to i8
%776 = tail call i64 @isalnum(i8 zeroext %775)
%777 = icmp ne i64 %776, 0
%778 = and i64 %773, 255
%779 = icmp eq i64 %778, 95
%780 = select i1 %777, i1 true, i1 %779
br i1 %780, label %759, label %781
781: ; preds = %772
%782 = getelementptr inbounds i8, i8* %0, i64 %774
%783 = ptrtoint i8* %782 to i64
%784 = ptrtoint i8* %756 to i64
%785 = xor i64 %784, -1
%786 = add i64 %783, %785
%787 = trunc i64 %786 to i32
%788 = tail call i32 @use_config(i8* %756, i32 %787)
br label %789
789: ; preds = %197, %530, %644, %311, %781, %213, %229, %245, %261, %277, %293, %381, %397, %413, %429, %445, %461, %477, %493, %509, %546, %562, %578, %594, %610, %626, %673, %689, %705, %721, %737, %753, %75
%790 = phi i64 [ %215, %213 ], [ %231, %229 ], [ %247, %245 ], [ %263, %261 ], [ %279, %277 ], [ %295, %293 ], [ %383, %381 ], [ %399, %397 ], [ %415, %413 ], [ %431, %429 ], [ %447, %445 ], [ %548, %546 ], [ %564, %562 ], [ %580, %578 ], [ %596, %594 ], [ %612, %610 ], [ %628, %626 ], [ %463, %461 ], [ %479, %477 ], [ %495, %493 ], [ %511, %509 ], [ %675, %673 ], [ %691, %689 ], [ %707, %705 ], [ %723, %721 ], [ %739, %737 ], [ %755, %753 ], [ %774, %781 ], [ %77, %75 ], [ %313, %311 ], [ %646, %644 ], [ %532, %530 ], [ %199, %197 ]
%791 = phi i64 [ %214, %213 ], [ %230, %229 ], [ %246, %245 ], [ %262, %261 ], [ %278, %277 ], [ %294, %293 ], [ %382, %381 ], [ %398, %397 ], [ %414, %413 ], [ %430, %429 ], [ %446, %445 ], [ %547, %546 ], [ %563, %562 ], [ %579, %578 ], [ %595, %594 ], [ %611, %610 ], [ %627, %626 ], [ %462, %461 ], [ %478, %477 ], [ %494, %493 ], [ %510, %509 ], [ %674, %673 ], [ %690, %689 ], [ %706, %705 ], [ %722, %721 ], [ %738, %737 ], [ %754, %753 ], [ %773, %781 ], [ %76, %75 ], [ %312, %311 ], [ %645, %644 ], [ %531, %530 ], [ %198, %197 ]
%792 = trunc i64 %791 to i32
%793 = and i32 %792, 255
%794 = add nsw i32 %793, -68
%795 = icmp ult i32 %794, -34
br i1 %795, label %23, label %26
796: ; preds = %11, %748, %732, %716, %700, %684, %668, %621, %605, %589, %573, %557, %541, %504, %488, %472, %456, %440, %424, %408, %392, %376, %288, %272, %256, %240, %224, %208, %70, %353, %326, %173, %158, %139, %124, %87, %54, %39, %767, %192, %525, %639, %306, %106
ret void
}