#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(char const);
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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) >
        ((('/') > ((('\'') > ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                   ? ('"')
                                   : ((('#') > ('C') ? ('#') : ('C')))))
                        ? ('\'')
                        : ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                ? ('"')
                                : ((('#') > ('C') ? ('#') : ('C')))))))
              ? ('/')
              : ((('\'') > ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                                 ? ('"')
                                 : ((('#') > ('C') ? ('#') : ('C')))))
                      ? ('\'')
                      : ((('"') > ((('#') > ('C') ? ('#') : ('C')))
                              ? ('"')
                              : ((('#') > ('C') ? ('#') : ('C'))))))))))
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) <
        ((('/') < ((('\'') < ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                   ? ('"')
                                   : ((('#') < ('C') ? ('#') : ('C')))))
                        ? ('\'')
                        : ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                ? ('"')
                                : ((('#') < ('C') ? ('#') : ('C')))))))
              ? ('/')
              : ((('\'') < ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                                 ? ('"')
                                 : ((('#') < ('C') ? ('#') : ('C')))))
                      ? ('\'')
                      : ((('"') < ((('#') < ('C') ? ('#') : ('C')))
                              ? ('"')
                              : ((('#') < ('C') ? ('#') : ('C'))))))))))
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '/')
      goto slash;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\'')
      goto squote;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '"')
      goto dquote;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '#')
      goto pound;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\n')
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '\\')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '/')
      goto slash_slash;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '*')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '*')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '/')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\'')
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '\\')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '"')
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '\\')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == ' ')
      goto pound;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\t')
      goto pound;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == 'i')
      goto pound_i;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == 'd')
      goto pound_d;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'n')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'c')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'l')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'u')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'd')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == ' ')
      goto pound_include;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\t')
      goto pound_include;
    map_dot = next;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '"')
      goto pound_include_dquote;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '<')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\n')
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '"')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\n')
      goto start;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '>')
      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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'e')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'f')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'i')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'n')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'n')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'd')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'e')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '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 ((__buf >> 8 * (sizeof(unsigned long) - 1)) == ' ')
      goto pound_define_undef;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) == '\t')
      goto pound_define_undef;
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'C')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'O')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'N')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'F')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'I')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'G')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '_')
      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((__buf >> 8 * (sizeof(unsigned long) - 1))) ||
        (__buf >> 8 * (sizeof(unsigned long) - 1)) == '_')
      goto pound_define_undef_CONFIG_word;
    goto __start;
  cee:
    if (next >= map + 2 && (isalnum(next[-2]) || next[-2] == '_'))
      goto start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'O')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'N')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'F')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'I')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != 'G')
      goto __start;
    {
      (__buf <<= 8);
      if ((unsigned long)next % sizeof(unsigned long) == 0) {
        if (next >= end)
          break;
        __buf = *(unsigned long *)next;
      }
      next++;
    }
    if ((__buf >> 8 * (sizeof(unsigned long) - 1)) != '_')
      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((__buf >> 8 * (sizeof(unsigned long) - 1))) ||
        (__buf >> 8 * (sizeof(unsigned long) - 1)) == '_')
      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
shl    $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    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x43,%rax
jbe    11b4 <state_machine+0x84>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x22,%rax
jae    11cb <state_machine+0x9b>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x2f,%rax
jne    11e2 <state_machine+0xb2>
jmp    1306 <state_machine+0x1d6>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x27,%rax
jne    11f9 <state_machine+0xc9>
jmp    1444 <state_machine+0x314>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x22,%rax
jne    1210 <state_machine+0xe0>
jmp    1507 <state_machine+0x3d7>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x23,%rax
jne    1227 <state_machine+0xf7>
jmp    15ca <state_machine+0x49a>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x43,%rax
jne    123e <state_machine+0x10e>
jmp    2159 <state_machine+0x1029>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    127f <state_machine+0x14f>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1274 <state_machine+0x144>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0xa,%rax
jne    12a2 <state_machine+0x172>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x5c,%rax
je     12b9 <state_machine+0x189>
jmp    1243 <state_machine+0x113>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    12f5 <state_machine+0x1c5>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     12ea <state_machine+0x1ba>
jmp    2475 <state_machine+0x1345>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1243 <state_machine+0x113>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1342 <state_machine+0x212>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1337 <state_machine+0x207>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x2f,%rax
jne    1365 <state_machine+0x235>
jmp    1243 <state_machine+0x113>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x2a,%rax
je     137c <state_machine+0x24c>
jmp    119d <state_machine+0x6d>
jmp    1381 <state_machine+0x251>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    13bd <state_machine+0x28d>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     13b2 <state_machine+0x282>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x2a,%rax
je     13e0 <state_machine+0x2b0>
jmp    1381 <state_machine+0x251>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    141c <state_machine+0x2ec>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1411 <state_machine+0x2e1>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x2f,%rax
je     143f <state_machine+0x30f>
jmp    13c9 <state_machine+0x299>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1480 <state_machine+0x350>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1475 <state_machine+0x345>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x27,%rax
jne    14a3 <state_machine+0x373>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x5c,%rax
je     14ba <state_machine+0x38a>
jmp    1444 <state_machine+0x314>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    14f6 <state_machine+0x3c6>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     14eb <state_machine+0x3bb>
jmp    2475 <state_machine+0x1345>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1444 <state_machine+0x314>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1543 <state_machine+0x413>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1538 <state_machine+0x408>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x22,%rax
jne    1566 <state_machine+0x436>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x5c,%rax
je     157d <state_machine+0x44d>
jmp    1507 <state_machine+0x3d7>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    15b9 <state_machine+0x489>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     15ae <state_machine+0x47e>
jmp    2475 <state_machine+0x1345>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1507 <state_machine+0x3d7>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1606 <state_machine+0x4d6>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     15fb <state_machine+0x4cb>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x20,%rax
jne    1629 <state_machine+0x4f9>
jmp    15ca <state_machine+0x49a>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x9,%rax
jne    1640 <state_machine+0x510>
jmp    15ca <state_machine+0x49a>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x69,%rax
jne    1657 <state_machine+0x527>
jmp    168a <state_machine+0x55a>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x64,%rax
jne    166e <state_machine+0x53e>
jmp    1aab <state_machine+0x97b>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x75,%rax
jne    1685 <state_machine+0x555>
jmp    1c8b <state_machine+0xb5b>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    16c6 <state_machine+0x596>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     16bb <state_machine+0x58b>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x6e,%rax
je     16e9 <state_machine+0x5b9>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1725 <state_machine+0x5f5>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     171a <state_machine+0x5ea>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x63,%rax
je     1748 <state_machine+0x618>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1784 <state_machine+0x654>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1779 <state_machine+0x649>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x6c,%rax
je     17a7 <state_machine+0x677>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    17e3 <state_machine+0x6b3>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     17d8 <state_machine+0x6a8>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x75,%rax
je     1806 <state_machine+0x6d6>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1842 <state_machine+0x712>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1837 <state_machine+0x707>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x64,%rax
je     1865 <state_machine+0x735>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    18a1 <state_machine+0x771>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1896 <state_machine+0x766>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x65,%rax
je     18c4 <state_machine+0x794>
jmp    119d <state_machine+0x6d>
jmp    18c9 <state_machine+0x799>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1905 <state_machine+0x7d5>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     18fa <state_machine+0x7ca>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x20,%rax
jne    1928 <state_machine+0x7f8>
jmp    18c9 <state_machine+0x799>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x9,%rax
jne    193f <state_machine+0x80f>
jmp    18c9 <state_machine+0x799>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x22,%rax
jne    195e <state_machine+0x82e>
jmp    197a <state_machine+0x84a>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x3c,%rax
jne    1975 <state_machine+0x845>
jmp    1a11 <state_machine+0x8e1>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    19b6 <state_machine+0x886>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     19ab <state_machine+0x87b>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0xa,%rax
jne    19d9 <state_machine+0x8a9>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x22,%rax
je     19f0 <state_machine+0x8c0>
jmp    197a <state_machine+0x84a>
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
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1a4d <state_machine+0x91d>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1a42 <state_machine+0x912>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0xa,%rax
jne    1a70 <state_machine+0x940>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x3e,%rax
je     1a87 <state_machine+0x957>
jmp    1a11 <state_machine+0x8e1>
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
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1ae7 <state_machine+0x9b7>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1adc <state_machine+0x9ac>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x65,%rax
je     1b0a <state_machine+0x9da>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1b46 <state_machine+0xa16>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1b3b <state_machine+0xa0b>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x66,%rax
je     1b69 <state_machine+0xa39>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1ba5 <state_machine+0xa75>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1b9a <state_machine+0xa6a>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x69,%rax
je     1bc8 <state_machine+0xa98>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1c04 <state_machine+0xad4>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1bf9 <state_machine+0xac9>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x6e,%rax
je     1c27 <state_machine+0xaf7>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1c63 <state_machine+0xb33>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1c58 <state_machine+0xb28>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x65,%rax
je     1c86 <state_machine+0xb56>
jmp    119d <state_machine+0x6d>
jmp    1e0c <state_machine+0xcdc>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1cc7 <state_machine+0xb97>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1cbc <state_machine+0xb8c>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x6e,%rax
je     1cea <state_machine+0xbba>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1d26 <state_machine+0xbf6>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1d1b <state_machine+0xbeb>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x64,%rax
je     1d49 <state_machine+0xc19>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1d85 <state_machine+0xc55>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1d7a <state_machine+0xc4a>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x65,%rax
je     1da8 <state_machine+0xc78>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1de4 <state_machine+0xcb4>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1dd9 <state_machine+0xca9>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x66,%rax
je     1e07 <state_machine+0xcd7>
jmp    119d <state_machine+0x6d>
jmp    1e0c <state_machine+0xcdc>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1e48 <state_machine+0xd18>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1e3d <state_machine+0xd0d>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x20,%rax
jne    1e6b <state_machine+0xd3b>
jmp    1e0c <state_machine+0xcdc>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x9,%rax
jne    1e82 <state_machine+0xd52>
jmp    1e0c <state_machine+0xcdc>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x43,%rax
je     1e99 <state_machine+0xd69>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1ed5 <state_machine+0xda5>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1eca <state_machine+0xd9a>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x4f,%rax
je     1ef8 <state_machine+0xdc8>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1f34 <state_machine+0xe04>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1f29 <state_machine+0xdf9>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x4e,%rax
je     1f57 <state_machine+0xe27>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1f93 <state_machine+0xe63>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1f88 <state_machine+0xe58>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x46,%rax
je     1fb6 <state_machine+0xe86>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1ff2 <state_machine+0xec2>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1fe7 <state_machine+0xeb7>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x49,%rax
je     2015 <state_machine+0xee5>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2051 <state_machine+0xf21>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2046 <state_machine+0xf16>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x47,%rax
je     2074 <state_machine+0xf44>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    20b0 <state_machine+0xf80>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     20a5 <state_machine+0xf75>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x5f,%rax
je     20d3 <state_machine+0xfa3>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2117 <state_machine+0xfe7>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     210c <state_machine+0xfdc>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
movsbl %al,%edi
call   1030 <isalnum@plt>
cmp    $0x0,%rax
jne    214f <state_machine+0x101f>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x5f,%rax
jne    2154 <state_machine+0x1024>
jmp    20db <state_machine+0xfab>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0x2,%rcx
cmp    %rcx,%rax
jb     219b <state_machine+0x106b>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%edi
call   1030 <isalnum@plt>
cmp    $0x0,%rax
jne    2196 <state_machine+0x1066>
mov    -0x18(%rbp),%rax
movsbl -0x2(%rax),%eax
cmp    $0x5f,%eax
jne    219b <state_machine+0x106b>
jmp    1155 <state_machine+0x25>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    21d7 <state_machine+0x10a7>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     21cc <state_machine+0x109c>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x4f,%rax
je     21fa <state_machine+0x10ca>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2236 <state_machine+0x1106>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     222b <state_machine+0x10fb>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x4e,%rax
je     2259 <state_machine+0x1129>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2295 <state_machine+0x1165>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     228a <state_machine+0x115a>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x46,%rax
je     22b8 <state_machine+0x1188>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    22f4 <state_machine+0x11c4>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     22e9 <state_machine+0x11b9>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x49,%rax
je     2317 <state_machine+0x11e7>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2353 <state_machine+0x1223>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     2348 <state_machine+0x1218>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x47,%rax
je     2376 <state_machine+0x1246>
jmp    119d <state_machine+0x6d>
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    23b2 <state_machine+0x1282>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     23a7 <state_machine+0x1277>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
cmp    $0x5f,%rax
je     23d5 <state_machine+0x12a5>
jmp    119d <state_machine+0x6d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    2419 <state_machine+0x12e9>
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     240e <state_machine+0x12de>
jmp    2475 <state_machine+0x1345>
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
shr    $0x38,%rax
movsbl %al,%edi
call   1030 <isalnum@plt>
cmp    $0x0,%rax
jne    2451 <state_machine+0x1321>
mov    -0x28(%rbp),%rax
shr    $0x38,%rax
cmp    $0x5f,%rax
jne    2456 <state_machine+0x1326>
jmp    23dd <state_machine+0x12ad>
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,%r15
movabs $0xff00000000000000,%r8
movabs $0xde00000000000000,%r9
movabs $0xbc00000000000000,%r10
lea    0x7(%rdi),%rax
mov    %rax,(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0x10(%rsp)
xor    %ebp,%ebp
lea    0xe84(%rip),%r11
xor    %r13d,%r13d
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     11a0 <state_machine+0x70>
shl    $0x8,%r13
add    $0x1,%rbp
jmp    11b0 <state_machine+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
add    $0x1,%rbp
lea    (%r10,%r13,1),%rax
cmp    %r9,%rax
jb     117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rbx
mov    %r13,%rax
shr    $0x38,%rax
add    $0xde,%al
movzbl %al,%eax
cmp    $0x21,%al
ja     117f <state_machine+0x4f>
movslq (%r11,%rax,4),%rax
add    %r11,%rax
jmp    *%rax
lea    0x3(%rbp),%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%rcx
lea    (%rdx,%rbp,1),%rdi
jmp    1209 <state_machine+0xd9>
nopl   0x0(%rax)
cmp    $0x9,%dl
jne    1393 <state_machine+0x263>
add    $0x1,%rax
add    $0x1,%rbp
add    $0x1,%rcx
add    $0x1,%rdi
lea    (%r15,%rax,1),%rdx
add    $0xfffffffffffffffd,%rdx
test   $0x7,%dl
je     1220 <state_machine+0xf0>
shl    $0x8,%r13
jmp    122e <state_machine+0xfe>
nopl   0x0(%rax)
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    -0x3(%r15,%rax,1),%r13
mov    %r13,%rdx
shr    $0x38,%rdx
cmp    $0x1f,%dl
jle    11f0 <state_machine+0xc0>
cmp    $0x63,%dl
jg     12c2 <state_machine+0x192>
cmp    $0x20,%dl
je     11f9 <state_machine+0xc9>
jmp    1393 <state_machine+0x263>
nopl   (%rax)
test   $0x7,%bl
je     12f7 <state_machine+0x1c7>
shl    $0x8,%r13
jmp    1303 <state_machine+0x1d3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x2,%rbp
jl     12b7 <state_machine+0x187>
movsbl -0x2(%rbx),%edi
call   1030 <isalnum@plt>
test   %rax,%rax
jne    1d9a <state_machine+0xc6a>
cmpb   $0x5f,-0x2(%rbx)
movabs $0xff00000000000000,%r8
movabs $0xde00000000000000,%r9
movabs $0xbc00000000000000,%r10
lea    0xd4f(%rip),%r11
je     117f <state_machine+0x4f>
test   $0x7,%bl
je     1323 <state_machine+0x1f3>
shl    $0x8,%r13
jmp    132f <state_machine+0x1ff>
cmp    $0x64,%dl
je     135f <state_machine+0x22f>
cmp    $0x69,%dl
je     1379 <state_machine+0x249>
cmp    $0x75,%dl
jne    1393 <state_machine+0x263>
lea    (%r15,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     141e <state_machine+0x2ee>
shl    $0x8,%r13
jmp    142c <state_machine+0x2fc>
cmp    %r14,%rbx
jae    1eb5 <state_machine+0xd85>
mov    (%rbx),%r13
add    $0x1,%rbp
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x2f,%al
je     1ccc <state_machine+0xb9c>
cmp    $0x2a,%al
jne    11b0 <state_machine+0x80>
jmp    1d82 <state_machine+0xc52>
cmp    %r14,%rbx
jae    1eb5 <state_machine+0xd85>
mov    (%rbx),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4f00000000000000,%rcx
cmp    %rcx,%rax
jne    1356 <state_machine+0x226>
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     139f <state_machine+0x26f>
shl    $0x8,%r13
jmp    13ab <state_machine+0x27b>
add    $0x1,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rcx
add    $0xfffffffffffffffe,%rcx
test   $0x7,%cl
je     145e <state_machine+0x32e>
shl    $0x8,%r13
jmp    146c <state_machine+0x33c>
lea    (%r15,%rax,1),%rdx
add    $0xfffffffffffffffe,%rdx
test   $0x7,%dl
je     149a <state_machine+0x36a>
shl    $0x8,%r13
jmp    14a8 <state_machine+0x378>
add    $0xfffffffffffffffe,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4e00000000000000,%rcx
cmp    %rcx,%rax
jne    13d2 <state_machine+0x2a2>
lea    (%r15,%rbp,1),%rax
add    $0x2,%rax
test   $0x7,%al
je     13db <state_machine+0x2ab>
shl    $0x8,%r13
jmp    13e7 <state_machine+0x2b7>
add    $0x2,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4600000000000000,%rcx
cmp    %rcx,%rax
jne    1415 <state_machine+0x2e5>
lea    (%r15,%rbp,1),%rax
add    $0x3,%rax
test   $0x7,%al
je     14e2 <state_machine+0x3b2>
shl    $0x8,%r13
jmp    14ee <state_machine+0x3be>
add    $0x3,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    -0x2(%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6e00000000000000,%rdx
cmp    %rdx,%rcx
jne    14d6 <state_machine+0x3a6>
lea    (%r15,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     1525 <state_machine+0x3f5>
shl    $0x8,%r13
jmp    153b <state_machine+0x40b>
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    -0x2(%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6500000000000000,%rdx
cmp    %rdx,%rcx
jne    14d6 <state_machine+0x3a6>
lea    (%r15,%rax,1),%ecx
add    $0xffffffff,%ecx
test   $0x7,%cl
je     156a <state_machine+0x43a>
shl    $0x8,%r13
jmp    1580 <state_machine+0x450>
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    -0x2(%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x6e00000000000000,%rsi
cmp    %rsi,%rdx
jne    14d6 <state_machine+0x3a6>
lea    (%r15,%rax,1),%edx
add    $0xffffffff,%edx
test   $0x7,%dl
je     15af <state_machine+0x47f>
shl    $0x8,%r13
jmp    15c5 <state_machine+0x495>
add    $0xffffffffffffffff,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4900000000000000,%rcx
cmp    %rcx,%rax
jne    151c <state_machine+0x3ec>
lea    (%r15,%rbp,1),%rax
add    $0x4,%rax
test   $0x7,%al
je     15f4 <state_machine+0x4c4>
shl    $0x8,%r13
jmp    1600 <state_machine+0x4d0>
add    $0x4,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    -0x1(%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6400000000000000,%rdx
cmp    %rdx,%rcx
jne    1397 <state_machine+0x267>
lea    (%r15,%rax,1),%ecx
test   $0x7,%cl
je     1637 <state_machine+0x507>
shl    $0x8,%r13
jmp    1648 <state_machine+0x518>
lea    (%r15,%rax,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    -0x1(%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6600000000000000,%rdx
cmp    %rdx,%rcx
jne    1397 <state_machine+0x267>
lea    (%r15,%rax,1),%ecx
test   $0x7,%cl
je     167a <state_machine+0x54a>
shl    $0x8,%r13
jmp    168b <state_machine+0x55b>
lea    (%r15,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    -0x1(%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x6300000000000000,%rsi
cmp    %rsi,%rdx
jne    1397 <state_machine+0x267>
lea    (%r15,%rax,1),%edx
test   $0x7,%dl
je     16b9 <state_machine+0x589>
shl    $0x8,%r13
jmp    16ca <state_machine+0x59a>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4700000000000000,%rcx
cmp    %rcx,%rax
jne    162e <state_machine+0x4fe>
lea    (%r15,%rbp,1),%rax
add    $0x5,%rax
test   $0x7,%al
je     1704 <state_machine+0x5d4>
shl    $0x8,%r13
jmp    1710 <state_machine+0x5e0>
add    $0x5,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6500000000000000,%rdx
cmp    %rdx,%rcx
jne    16f8 <state_machine+0x5c8>
lea    (%r15,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     17be <state_machine+0x68e>
shl    $0x8,%r13
jmp    17d4 <state_machine+0x6a4>
lea    (%r15,%rax,1),%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6900000000000000,%rdx
cmp    %rdx,%rcx
jne    16f8 <state_machine+0x5c8>
lea    (%r15,%rax,1),%ecx
add    $0x1,%ecx
test   $0x7,%cl
je     17f9 <state_machine+0x6c9>
shl    $0x8,%r13
jmp    180f <state_machine+0x6df>
lea    (%r15,%rax,1),%rdx
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x6c00000000000000,%rsi
cmp    %rsi,%rdx
jne    16f8 <state_machine+0x5c8>
lea    (%r15,%rax,1),%edx
add    $0x1,%edx
test   $0x7,%dl
je     1836 <state_machine+0x706>
shl    $0x8,%r13
jmp    184c <state_machine+0x71c>
add    $0x1,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
lea    0x6(%rbp),%r12
mov    %r13,%rax
and    %r8,%rax
movabs $0x5f00000000000000,%rcx
cmp    %rcx,%rax
jne    17b6 <state_machine+0x686>
lea    (%r15,%rbp,1),%rax
add    $0x6,%rax
mov    %rax,0x8(%rsp)
mov    $0xffffffff,%ebp
nop
lea    (%r15,%r12,1),%rax
test   $0x7,%al
je     1750 <state_machine+0x620>
shl    $0x8,%r13
jmp    175d <state_machine+0x62d>
xchg   %ax,%ax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%r12,1),%r13
add    $0x1,%r12
mov    %r13,%rbx
shr    $0x38,%rbx
movsbl %bl,%edi
call   1030 <isalnum@plt>
add    $0x1,%ebp
test   %rax,%rax
jne    1740 <state_machine+0x610>
cmp    $0x5f,%ebx
je     1740 <state_machine+0x610>
mov    0x8(%rsp),%rdi
mov    %ebp,%esi
call   1050 <use_config@plt>
lea    0x870(%rip),%r11
movabs $0xbc00000000000000,%r10
movabs $0xde00000000000000,%r9
movabs $0xff00000000000000,%r8
mov    %r12,%rbp
jmp    11b0 <state_machine+0x80>
mov    %r12,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    0x1(%r15,%rax,1),%r13
add    $0x2,%rax
mov    %r13,%rcx
and    %r8,%rcx
mov    %rax,%rbp
movabs $0x6600000000000000,%rdx
cmp    %rdx,%rcx
jne    11b0 <state_machine+0x80>
jmp    18bc <state_machine+0x78c>
lea    (%r15,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    0x1(%r15,%rax,1),%r13
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x6e00000000000000,%rdx
cmp    %rdx,%rcx
jne    187a <state_machine+0x74a>
lea    (%r15,%rax,1),%ecx
add    $0x2,%ecx
test   $0x7,%cl
je     1886 <state_machine+0x756>
shl    $0x8,%r13
jmp    189c <state_machine+0x76c>
lea    (%r15,%rax,1),%rdx
add    $0x1,%rdx
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    0x1(%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x7500000000000000,%rsi
cmp    %rsi,%rdx
jne    187a <state_machine+0x74a>
lea    (%r15,%rax,1),%edx
add    $0x2,%edx
test   $0x7,%dl
je     192c <state_machine+0x7fc>
shl    $0x8,%r13
jmp    1942 <state_machine+0x812>
add    $0x2,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rcx
add    $0x2,%rcx
cmp    %r14,%rcx
jae    1eb5 <state_machine+0xd85>
mov    0x2(%r15,%rax,1),%r13
add    $0x3,%rax
mov    %r13,%rcx
and    %r8,%rcx
mov    %rax,%rbp
movabs $0x6500000000000000,%rdx
cmp    %rdx,%rcx
jne    11b0 <state_machine+0x80>
add    $0x7,%rax
mov    %rax,%rbp
jmp    18d4 <state_machine+0x7a4>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffff9,%rax
test   $0x7,%al
je     18f0 <state_machine+0x7c0>
shl    $0x8,%r13
jmp    18fe <state_machine+0x7ce>
cs nopw 0x0(%rax,%rax,1)
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x7(%r15,%rbp,1),%r13
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x9,%al
je     18d0 <state_machine+0x7a0>
cmp    $0x20,%al
je     18d0 <state_machine+0x7a0>
cmp    $0x43,%al
jne    1923 <state_machine+0x7f3>
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffffa,%rax
test   $0x7,%al
je     1975 <state_machine+0x845>
shl    $0x8,%r13
jmp    1983 <state_machine+0x853>
add    $0xfffffffffffffffa,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rdx
add    $0x2,%rdx
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    0x2(%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x6400000000000000,%rsi
cmp    %rsi,%rdx
jne    1969 <state_machine+0x839>
lea    (%r15,%rax,1),%edx
add    $0x3,%edx
test   $0x7,%dl
je     19b9 <state_machine+0x889>
shl    $0x8,%r13
jmp    19cf <state_machine+0x89f>
add    $0x3,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x6(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4f00000000000000,%rcx
cmp    %rcx,%rax
jne    19b0 <state_machine+0x880>
lea    (%r15,%rbp,1),%eax
add    $0xfffffffb,%eax
test   $0x7,%al
je     1a55 <state_machine+0x925>
shl    $0x8,%r13
jmp    1a6b <state_machine+0x93b>
add    $0xfffffffffffffffb,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rax,1),%rdx
add    $0x3,%rdx
cmp    %r14,%rdx
jae    1eb5 <state_machine+0xd85>
mov    0x3(%r15,%rax,1),%r13
mov    %r13,%rdx
and    %r8,%rdx
movabs $0x6500000000000000,%rsi
cmp    %rsi,%rdx
jne    1a49 <state_machine+0x919>
mov    (%rsp),%rdx
jmp    19fa <state_machine+0x8ca>
cmp    $0x9,%al
jne    1a40 <state_machine+0x910>
add    $0x1,%rbp
add    $0x1,%rcx
add    $0x1,%rdi
lea    (%rdx,%rbp,1),%eax
test   $0x7,%al
je     1a07 <state_machine+0x8d7>
shl    $0x8,%r13
jmp    1a21 <state_machine+0x8f1>
lea    (%r15,%rbp,1),%rax
add    $0x7,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    0x7(%r15,%rbp,1),%r13
mov    (%rsp),%rdx
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x1f,%al
jle    19ea <state_machine+0x8ba>
cmp    $0x20,%al
je     19ee <state_machine+0x8be>
cmp    $0x22,%al
je     1dc4 <state_machine+0xc94>
cmp    $0x3c,%al
je     1e3f <state_machine+0xd0f>
add    $0x8,%rbp
jmp    11b0 <state_machine+0x80>
add    $0x4,%rax
mov    %rax,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffffb,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x5(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4e00000000000000,%rcx
cmp    %rcx,%rax
jne    1a91 <state_machine+0x961>
lea    (%r15,%rbp,1),%eax
add    $0xfffffffc,%eax
test   $0x7,%al
je     1a9a <state_machine+0x96a>
shl    $0x8,%r13
jmp    1ab0 <state_machine+0x980>
add    $0xfffffffffffffffc,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffffc,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x4(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4600000000000000,%rcx
cmp    %rcx,%rax
jne    1ad6 <state_machine+0x9a6>
lea    (%r15,%rbp,1),%eax
add    $0xfffffffd,%eax
test   $0x7,%al
je     1adf <state_machine+0x9af>
shl    $0x8,%r13
jmp    1af5 <state_machine+0x9c5>
add    $0xfffffffffffffffd,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffffd,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x3(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4900000000000000,%rcx
cmp    %rcx,%rax
jne    1b1b <state_machine+0x9eb>
lea    (%r15,%rbp,1),%eax
add    $0xfffffffe,%eax
test   $0x7,%al
je     1b24 <state_machine+0x9f4>
shl    $0x8,%r13
jmp    1b3a <state_machine+0xa0a>
add    $0xfffffffffffffffe,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
add    $0xfffffffffffffffe,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x2(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x4700000000000000,%rcx
cmp    %rcx,%rax
jne    1b60 <state_machine+0xa30>
lea    (%r15,%rbp,1),%eax
add    $0xffffffff,%eax
test   $0x7,%al
je     1b69 <state_machine+0xa39>
shl    $0x8,%r13
jmp    1b7f <state_machine+0xa4f>
add    $0xffffffffffffffff,%rbp
jmp    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    -0x1(%r15,%rbp,1),%r13
mov    %r13,%rax
and    %r8,%rax
movabs $0x5f00000000000000,%rcx
cmp    %rcx,%rax
jne    11b0 <state_machine+0x80>
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     1ba6 <state_machine+0xa76>
shl    $0x8,%r13
jmp    1bb3 <state_machine+0xa83>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%rbp,1),%r13
add    $0x1,%rbp
mov    %r13,%rbx
shr    $0x38,%rbx
movsbl %bl,%edi
call   1030 <isalnum@plt>
test   %rax,%rax
movabs $0xff00000000000000,%r8
movabs $0xde00000000000000,%r9
movabs $0xbc00000000000000,%r10
lea    0x412(%rip),%r11
jne    1b98 <state_machine+0xa68>
cmp    $0x5f,%ebx
je     1b98 <state_machine+0xa68>
jmp    11b0 <state_machine+0x80>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x22,%al
je     117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     1c20 <state_machine+0xaf0>
shl    $0x8,%r13
jmp    1c2c <state_machine+0xafc>
nopw   0x0(%rax,%rax,1)
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x5c,%al
jne    1c00 <state_machine+0xad0>
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1c4d <state_machine+0xb1d>
shl    $0x8,%r13
add    $0x2,%rbp
jmp    1c0c <state_machine+0xadc>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1c0c <state_machine+0xadc>
nop
add    $0x1,%rbp
cmp    $0x27,%al
je     117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     1c80 <state_machine+0xb50>
shl    $0x8,%r13
jmp    1c8c <state_machine+0xb5c>
nopw   0x0(%rax,%rax,1)
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x5c,%al
jne    1c60 <state_machine+0xb30>
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1cad <state_machine+0xb7d>
shl    $0x8,%r13
add    $0x2,%rbp
jmp    1c6c <state_machine+0xb3c>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1c6c <state_machine+0xb3c>
nop
add    $0x1,%rbp
cmp    $0xa,%al
je     117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     1ce0 <state_machine+0xbb0>
shl    $0x8,%r13
jmp    1cec <state_machine+0xbbc>
nopw   0x0(%rax,%rax,1)
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0x5c,%al
jne    1cc0 <state_machine+0xb90>
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
test   $0x7,%al
je     1d0d <state_machine+0xbdd>
shl    $0x8,%r13
add    $0x2,%rbp
jmp    1ccc <state_machine+0xb9c>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%rax),%r13
add    $0x2,%rbp
jmp    1ccc <state_machine+0xb9c>
mov    (%rax),%r13
add    $0x1,%rbp
jmp    1d51 <state_machine+0xc21>
nopl   0x0(%rax,%rax,1)
shl    $0x8,%r13
add    $0x1,%rbp
mov    %r13,%rax
and    %r8,%rax
movabs $0x2f00000000000000,%rcx
cmp    %rcx,%rax
je     117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rax
mov    %r13,%rcx
and    %r8,%rcx
movabs $0x2a00000000000000,%rdx
cmp    %rdx,%rcx
jne    1d82 <state_machine+0xc52>
lea    (%r15,%rbp,1),%ecx
test   $0x7,%cl
jne    1d30 <state_machine+0xc00>
cmp    %r14,%rax
jae    1eb5 <state_machine+0xd85>
mov    (%r15,%rbp,1),%r13
jmp    1d34 <state_machine+0xc04>
lea    (%r15,%rbp,1),%rax
test   $0x7,%al
je     1d90 <state_machine+0xc60>
shl    $0x8,%r13
jmp    1d22 <state_machine+0xbf2>
cmp    %r14,%rax
jb     1d1f <state_machine+0xbef>
jmp    1eb5 <state_machine+0xd85>
movabs $0xff00000000000000,%r8
movabs $0xde00000000000000,%r9
movabs $0xbc00000000000000,%r10
lea    0x241(%rip),%r11
jmp    117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffff,%edx
test   $0x7,%cl
je     1de0 <state_machine+0xcb0>
shl    $0x8,%r13
jmp    1dec <state_machine+0xcbc>
cmp    %r14,%rdi
jae    1eb5 <state_machine+0xd85>
mov    (%rdi),%r13
add    $0x1,%rbp
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0xa,%al
je     117f <state_machine+0x4f>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%edx
cmp    $0x22,%al
jne    1dd5 <state_machine+0xca5>
xor    %edi,%edi
call   1040 <handle_include@plt>
lea    0x1e4(%rip),%r11
movabs $0xbc00000000000000,%r10
movabs $0xde00000000000000,%r9
movabs $0xff00000000000000,%r8
jmp    117f <state_machine+0x4f>
lea    (%r15,%rbp,1),%rsi
add    $0x8,%rsi
add    $0x8,%rbp
mov    $0xffffffff,%edx
test   $0x7,%cl
je     1e5b <state_machine+0xd2b>
shl    $0x8,%r13
jmp    1e63 <state_machine+0xd33>
cmp    %r14,%rdi
jae    1eb5 <state_machine+0xd85>
mov    (%rdi),%r13
add    $0x1,%rbp
mov    %r13,%rax
shr    $0x38,%rax
cmp    $0xa,%al
je     1e92 <state_machine+0xd62>
add    $0x1,%rcx
add    $0x1,%rdi
add    $0x1,%edx
cmp    $0x3e,%al
jne    1e50 <state_machine+0xd20>
mov    $0x1,%edi
call   1040 <handle_include@plt>
lea    0x16e(%rip),%r11
movabs $0xff00000000000000,%r8
movabs $0xde00000000000000,%r9
movabs $0xbc00000000000000,%r10
jmp    117f <state_machine+0x4f>
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 = %1011, %572, %566, %534, %528, %258, %211, %188, %87, %64, %38, %33, %9
%11 = load i64, i64* %7
%12 = shl 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 %1191
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 = %1181, %1149, %1126, %1103, %1080, %1057, %1034, %993, %961, %938, %915, %892, %869, %846, %823, %789, %766, %743, %720, %696, %673, %650, %627, %604, %505, %464, %441, %418, %395, %372, %349, %326, %139, %26
%30 = load i64, i64* %7
%31 = lshr i64 %30, 56
%32 = icmp ugt i64 %31, 67
br i1 %32, label %33, label %34
33: ; preds = %29
br label %10
34: ; preds = %29
%35 = load i64, i64* %7
%36 = lshr i64 %35, 56
%37 = icmp ult i64 %36, 34
br i1 %37, label %38, label %39
38: ; preds = %34
br label %10
39: ; preds = %34
%40 = load i64, i64* %7
%41 = lshr i64 %40, 56
%42 = icmp eq i64 %41, 47
br i1 %42, label %43, label %44
43: ; preds = %39
br label %112
44: ; preds = %39
%45 = load i64, i64* %7
%46 = lshr i64 %45, 56
%47 = icmp eq i64 %46, 39
br i1 %47, label %48, label %49
48: ; preds = %44
br label %189
49: ; preds = %44
%50 = load i64, i64* %7
%51 = lshr i64 %50, 56
%52 = icmp eq i64 %51, 34
br i1 %52, label %53, label %54
53: ; preds = %49
br label %236
54: ; preds = %49
%55 = load i64, i64* %7
%56 = lshr i64 %55, 56
%57 = icmp eq i64 %56, 35
br i1 %57, label %58, label %59
58: ; preds = %54
br label %283
59: ; preds = %54
%60 = load i64, i64* %7
%61 = lshr i64 %60, 56
%62 = icmp eq i64 %61, 67
br i1 %62, label %63, label %64
63: ; preds = %59
br label %994
64: ; preds = %59
br label %10
65: ; preds = %134, %109, %92
%66 = load i64, i64* %7
%67 = shl i64 %66, 8
store i64 %67, i64* %7
%68 = load i8*, i8** %5
%69 = ptrtoint i8* %68 to i64
%70 = urem i64 %69, 8
%71 = icmp eq i64 %70, 0
br i1 %71, label %72, label %81
72: ; preds = %65
%73 = load i8*, i8** %5
%74 = load i8*, i8** %4
%75 = icmp uge i8* %73, %74
br i1 %75, label %76, label %77
76: ; preds = %72
br label %1191
77: ; preds = %72
%78 = load i8*, i8** %5
%79 = bitcast i8* %78 to i64*
%80 = load i64, i64* %79
store i64 %80, i64* %7
br label %81
81: ; preds = %77, %65
%82 = load i8*, i8** %5
%83 = getelementptr inbounds i8, i8* %82, i32 1
store i8* %83, i8** %5
%84 = load i64, i64* %7
%85 = lshr i64 %84, 56
%86 = icmp eq i64 %85, 10
br i1 %86, label %87, label %88
87: ; preds = %81
br label %10
88: ; preds = %81
%89 = load i64, i64* %7
%90 = lshr i64 %89, 56
%91 = icmp ne i64 %90, 92
br i1 %91, label %92, label %93
92: ; preds = %88
br label %65
93: ; preds = %88
%94 = load i64, i64* %7
%95 = shl i64 %94, 8
store i64 %95, i64* %7
%96 = load i8*, i8** %5
%97 = ptrtoint i8* %96 to i64
%98 = urem i64 %97, 8
%99 = icmp eq i64 %98, 0
br i1 %99, label %100, label %109
100: ; preds = %93
%101 = load i8*, i8** %5
%102 = load i8*, i8** %4
%103 = icmp uge i8* %101, %102
br i1 %103, label %104, label %105
104: ; preds = %100
br label %1191
105: ; preds = %100
%106 = load i8*, i8** %5
%107 = bitcast i8* %106 to i64*
%108 = load i64, i64* %107
store i64 %108, i64* %7
br label %109
109: ; preds = %105, %93
%110 = load i8*, i8** %5
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %5
br label %65
112: ; preds = %43
%113 = load i64, i64* %7
%114 = shl i64 %113, 8
store i64 %114, i64* %7
%115 = load i8*, i8** %5
%116 = ptrtoint i8* %115 to i64
%117 = urem i64 %116, 8
%118 = icmp eq i64 %117, 0
br i1 %118, label %119, label %128
119: ; preds = %112
%120 = load i8*, i8** %5
%121 = load i8*, i8** %4
%122 = icmp uge i8* %120, %121
br i1 %122, label %123, label %124
123: ; preds = %119
br label %1191
124: ; preds = %119
%125 = load i8*, i8** %5
%126 = bitcast i8* %125 to i64*
%127 = load i64, i64* %126
store i64 %127, i64* %7
br label %128
128: ; preds = %124, %112
%129 = load i8*, i8** %5
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %5
%131 = load i64, i64* %7
%132 = lshr i64 %131, 56
%133 = icmp eq i64 %132, 47
br i1 %133, label %134, label %135
134: ; preds = %128
br label %65
135: ; preds = %128
%136 = load i64, i64* %7
%137 = lshr i64 %136, 56
%138 = icmp ne i64 %137, 42
br i1 %138, label %139, label %140
139: ; preds = %135
br label %29
140: ; preds = %135
br label %141
141: ; preds = %164, %140
%142 = load i64, i64* %7
%143 = shl i64 %142, 8
store i64 %143, i64* %7
%144 = load i8*, i8** %5
%145 = ptrtoint i8* %144 to i64
%146 = urem i64 %145, 8
%147 = icmp eq i64 %146, 0
br i1 %147, label %148, label %157
148: ; preds = %141
%149 = load i8*, i8** %5
%150 = load i8*, i8** %4
%151 = icmp uge i8* %149, %150
br i1 %151, label %152, label %153
152: ; preds = %148
br label %1191
153: ; preds = %148
%154 = load i8*, i8** %5
%155 = bitcast i8* %154 to i64*
%156 = load i64, i64* %155
store i64 %156, i64* %7
br label %157
157: ; preds = %153, %141
%158 = load i8*, i8** %5
%159 = getelementptr inbounds i8, i8* %158, i32 1
store i8* %159, i8** %5
br label %160
160: ; preds = %187, %157
%161 = load i64, i64* %7
%162 = lshr i64 %161, 56
%163 = icmp ne i64 %162, 42
br i1 %163, label %164, label %165
164: ; preds = %160
br label %141
165: ; preds = %160
%166 = load i64, i64* %7
%167 = shl i64 %166, 8
store i64 %167, i64* %7
%168 = load i8*, i8** %5
%169 = ptrtoint i8* %168 to i64
%170 = urem i64 %169, 8
%171 = icmp eq i64 %170, 0
br i1 %171, label %172, label %181
172: ; preds = %165
%173 = load i8*, i8** %5
%174 = load i8*, i8** %4
%175 = icmp uge i8* %173, %174
br i1 %175, label %176, label %177
176: ; preds = %172
br label %1191
177: ; preds = %172
%178 = load i8*, i8** %5
%179 = bitcast i8* %178 to i64*
%180 = load i64, i64* %179
store i64 %180, i64* %7
br label %181
181: ; preds = %177, %165
%182 = load i8*, i8** %5
%183 = getelementptr inbounds i8, i8* %182, i32 1
store i8* %183, i8** %5
%184 = load i64, i64* %7
%185 = lshr i64 %184, 56
%186 = icmp ne i64 %185, 47
br i1 %186, label %187, label %188
187: ; preds = %181
br label %160
188: ; preds = %181
br label %10
189: ; preds = %233, %216, %48
%190 = load i64, i64* %7
%191 = shl i64 %190, 8
store i64 %191, i64* %7
%192 = load i8*, i8** %5
%193 = ptrtoint i8* %192 to i64
%194 = urem i64 %193, 8
%195 = icmp eq i64 %194, 0
br i1 %195, label %196, label %205
196: ; preds = %189
%197 = load i8*, i8** %5
%198 = load i8*, i8** %4
%199 = icmp uge i8* %197, %198
br i1 %199, label %200, label %201
200: ; preds = %196
br label %1191
201: ; preds = %196
%202 = load i8*, i8** %5
%203 = bitcast i8* %202 to i64*
%204 = load i64, i64* %203
store i64 %204, i64* %7
br label %205
205: ; preds = %201, %189
%206 = load i8*, i8** %5
%207 = getelementptr inbounds i8, i8* %206, i32 1
store i8* %207, i8** %5
%208 = load i64, i64* %7
%209 = lshr i64 %208, 56
%210 = icmp eq i64 %209, 39
br i1 %210, label %211, label %212
211: ; preds = %205
br label %10
212: ; preds = %205
%213 = load i64, i64* %7
%214 = lshr i64 %213, 56
%215 = icmp ne i64 %214, 92
br i1 %215, label %216, label %217
216: ; preds = %212
br label %189
217: ; preds = %212
%218 = load i64, i64* %7
%219 = shl i64 %218, 8
store i64 %219, i64* %7
%220 = load i8*, i8** %5
%221 = ptrtoint i8* %220 to i64
%222 = urem i64 %221, 8
%223 = icmp eq i64 %222, 0
br i1 %223, label %224, label %233
224: ; preds = %217
%225 = load i8*, i8** %5
%226 = load i8*, i8** %4
%227 = icmp uge i8* %225, %226
br i1 %227, label %228, label %229
228: ; preds = %224
br label %1191
229: ; preds = %224
%230 = load i8*, i8** %5
%231 = bitcast i8* %230 to i64*
%232 = load i64, i64* %231
store i64 %232, i64* %7
br label %233
233: ; preds = %229, %217
%234 = load i8*, i8** %5
%235 = getelementptr inbounds i8, i8* %234, i32 1
store i8* %235, i8** %5
br label %189
236: ; preds = %280, %263, %53
%237 = load i64, i64* %7
%238 = shl i64 %237, 8
store i64 %238, i64* %7
%239 = load i8*, i8** %5
%240 = ptrtoint i8* %239 to i64
%241 = urem i64 %240, 8
%242 = icmp eq i64 %241, 0
br i1 %242, label %243, label %252
243: ; preds = %236
%244 = load i8*, i8** %5
%245 = load i8*, i8** %4
%246 = icmp uge i8* %244, %245
br i1 %246, label %247, label %248
247: ; preds = %243
br label %1191
248: ; preds = %243
%249 = load i8*, i8** %5
%250 = bitcast i8* %249 to i64*
%251 = load i64, i64* %250
store i64 %251, i64* %7
br label %252
252: ; preds = %248, %236
%253 = load i8*, i8** %5
%254 = getelementptr inbounds i8, i8* %253, i32 1
store i8* %254, i8** %5
%255 = load i64, i64* %7
%256 = lshr i64 %255, 56
%257 = icmp eq i64 %256, 34
br i1 %257, label %258, label %259
258: ; preds = %252
br label %10
259: ; preds = %252
%260 = load i64, i64* %7
%261 = lshr i64 %260, 56
%262 = icmp ne i64 %261, 92
br i1 %262, label %263, label %264
263: ; preds = %259
br label %236
264: ; preds = %259
%265 = load i64, i64* %7
%266 = shl i64 %265, 8
store i64 %266, i64* %7
%267 = load i8*, i8** %5
%268 = ptrtoint i8* %267 to i64
%269 = urem i64 %268, 8
%270 = icmp eq i64 %269, 0
br i1 %270, label %271, label %280
271: ; preds = %264
%272 = load i8*, i8** %5
%273 = load i8*, i8** %4
%274 = icmp uge i8* %272, %273
br i1 %274, label %275, label %276
275: ; preds = %271
br label %1191
276: ; preds = %271
%277 = load i8*, i8** %5
%278 = bitcast i8* %277 to i64*
%279 = load i64, i64* %278
store i64 %279, i64* %7
br label %280
280: ; preds = %276, %264
%281 = load i8*, i8** %5
%282 = getelementptr inbounds i8, i8* %281, i32 1
store i8* %282, i8** %5
br label %236
283: ; preds = %310, %305, %58
%284 = load i64, i64* %7
%285 = shl i64 %284, 8
store i64 %285, i64* %7
%286 = load i8*, i8** %5
%287 = ptrtoint i8* %286 to i64
%288 = urem i64 %287, 8
%289 = icmp eq i64 %288, 0
br i1 %289, label %290, label %299
290: ; preds = %283
%291 = load i8*, i8** %5
%292 = load i8*, i8** %4
%293 = icmp uge i8* %291, %292
br i1 %293, label %294, label %295
294: ; preds = %290
br label %1191
295: ; preds = %290
%296 = load i8*, i8** %5
%297 = bitcast i8* %296 to i64*
%298 = load i64, i64* %297
store i64 %298, i64* %7
br label %299
299: ; preds = %295, %283
%300 = load i8*, i8** %5
%301 = getelementptr inbounds i8, i8* %300, i32 1
store i8* %301, i8** %5
%302 = load i64, i64* %7
%303 = lshr i64 %302, 56
%304 = icmp eq i64 %303, 32
br i1 %304, label %305, label %306
305: ; preds = %299
br label %283
306: ; preds = %299
%307 = load i64, i64* %7
%308 = lshr i64 %307, 56
%309 = icmp eq i64 %308, 9
br i1 %309, label %310, label %311
310: ; preds = %306
br label %283
311: ; preds = %306
%312 = load i64, i64* %7
%313 = lshr i64 %312, 56
%314 = icmp eq i64 %313, 105
br i1 %314, label %315, label %316
315: ; preds = %311
br label %327
316: ; preds = %311
%317 = load i64, i64* %7
%318 = lshr i64 %317, 56
%319 = icmp eq i64 %318, 100
br i1 %319, label %320, label %321
320: ; preds = %316
br label %582
321: ; preds = %316
%322 = load i64, i64* %7
%323 = lshr i64 %322, 56
%324 = icmp eq i64 %323, 117
br i1 %324, label %325, label %326
325: ; preds = %321
br label %698
326: ; preds = %321
br label %29
327: ; preds = %315
%328 = load i64, i64* %7
%329 = shl i64 %328, 8
store i64 %329, i64* %7
%330 = load i8*, i8** %5
%331 = ptrtoint i8* %330 to i64
%332 = urem i64 %331, 8
%333 = icmp eq i64 %332, 0
br i1 %333, label %334, label %343
334: ; preds = %327
%335 = load i8*, i8** %5
%336 = load i8*, i8** %4
%337 = icmp uge i8* %335, %336
br i1 %337, label %338, label %339
338: ; preds = %334
br label %1191
339: ; preds = %334
%340 = load i8*, i8** %5
%341 = bitcast i8* %340 to i64*
%342 = load i64, i64* %341
store i64 %342, i64* %7
br label %343
343: ; preds = %339, %327
%344 = load i8*, i8** %5
%345 = getelementptr inbounds i8, i8* %344, i32 1
store i8* %345, i8** %5
%346 = load i64, i64* %7
%347 = lshr i64 %346, 56
%348 = icmp ne i64 %347, 110
br i1 %348, label %349, label %350
349: ; preds = %343
br label %29
350: ; preds = %343
%351 = load i64, i64* %7
%352 = shl i64 %351, 8
store i64 %352, i64* %7
%353 = load i8*, i8** %5
%354 = ptrtoint i8* %353 to i64
%355 = urem i64 %354, 8
%356 = icmp eq i64 %355, 0
br i1 %356, label %357, label %366
357: ; preds = %350
%358 = load i8*, i8** %5
%359 = load i8*, i8** %4
%360 = icmp uge i8* %358, %359
br i1 %360, label %361, label %362
361: ; preds = %357
br label %1191
362: ; preds = %357
%363 = load i8*, i8** %5
%364 = bitcast i8* %363 to i64*
%365 = load i64, i64* %364
store i64 %365, i64* %7
br label %366
366: ; preds = %362, %350
%367 = load i8*, i8** %5
%368 = getelementptr inbounds i8, i8* %367, i32 1
store i8* %368, i8** %5
%369 = load i64, i64* %7
%370 = lshr i64 %369, 56
%371 = icmp ne i64 %370, 99
br i1 %371, label %372, label %373
372: ; preds = %366
br label %29
373: ; preds = %366
%374 = load i64, i64* %7
%375 = shl 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 %1191
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 = lshr i64 %392, 56
%394 = icmp ne i64 %393, 108
br i1 %394, label %395, label %396
395: ; preds = %389
br label %29
396: ; preds = %389
%397 = load i64, i64* %7
%398 = shl i64 %397, 8
store i64 %398, i64* %7
%399 = load i8*, i8** %5
%400 = ptrtoint i8* %399 to i64
%401 = urem i64 %400, 8
%402 = icmp eq i64 %401, 0
br i1 %402, label %403, label %412
403: ; preds = %396
%404 = load i8*, i8** %5
%405 = load i8*, i8** %4
%406 = icmp uge i8* %404, %405
br i1 %406, label %407, label %408
407: ; preds = %403
br label %1191
408: ; preds = %403
%409 = load i8*, i8** %5
%410 = bitcast i8* %409 to i64*
%411 = load i64, i64* %410
store i64 %411, i64* %7
br label %412
412: ; preds = %408, %396
%413 = load i8*, i8** %5
%414 = getelementptr inbounds i8, i8* %413, i32 1
store i8* %414, i8** %5
%415 = load i64, i64* %7
%416 = lshr i64 %415, 56
%417 = icmp ne i64 %416, 117
br i1 %417, label %418, label %419
418: ; preds = %412
br label %29
419: ; preds = %412
%420 = load i64, i64* %7
%421 = shl i64 %420, 8
store i64 %421, i64* %7
%422 = load i8*, i8** %5
%423 = ptrtoint i8* %422 to i64
%424 = urem i64 %423, 8
%425 = icmp eq i64 %424, 0
br i1 %425, label %426, label %435
426: ; preds = %419
%427 = load i8*, i8** %5
%428 = load i8*, i8** %4
%429 = icmp uge i8* %427, %428
br i1 %429, label %430, label %431
430: ; preds = %426
br label %1191
431: ; preds = %426
%432 = load i8*, i8** %5
%433 = bitcast i8* %432 to i64*
%434 = load i64, i64* %433
store i64 %434, i64* %7
br label %435
435: ; preds = %431, %419
%436 = load i8*, i8** %5
%437 = getelementptr inbounds i8, i8* %436, i32 1
store i8* %437, i8** %5
%438 = load i64, i64* %7
%439 = lshr i64 %438, 56
%440 = icmp ne i64 %439, 100
br i1 %440, label %441, label %442
441: ; preds = %435
br label %29
442: ; preds = %435
%443 = load i64, i64* %7
%444 = shl i64 %443, 8
store i64 %444, i64* %7
%445 = load i8*, i8** %5
%446 = ptrtoint i8* %445 to i64
%447 = urem i64 %446, 8
%448 = icmp eq i64 %447, 0
br i1 %448, label %449, label %458
449: ; preds = %442
%450 = load i8*, i8** %5
%451 = load i8*, i8** %4
%452 = icmp uge i8* %450, %451
br i1 %452, label %453, label %454
453: ; preds = %449
br label %1191
454: ; preds = %449
%455 = load i8*, i8** %5
%456 = bitcast i8* %455 to i64*
%457 = load i64, i64* %456
store i64 %457, i64* %7
br label %458
458: ; preds = %454, %442
%459 = load i8*, i8** %5
%460 = getelementptr inbounds i8, i8* %459, i32 1
store i8* %460, i8** %5
%461 = load i64, i64* %7
%462 = lshr i64 %461, 56
%463 = icmp ne i64 %462, 101
br i1 %463, label %464, label %465
464: ; preds = %458
br label %29
465: ; preds = %458
br label %466
466: ; preds = %493, %488, %465
%467 = load i64, i64* %7
%468 = shl i64 %467, 8
store i64 %468, i64* %7
%469 = load i8*, i8** %5
%470 = ptrtoint i8* %469 to i64
%471 = urem i64 %470, 8
%472 = icmp eq i64 %471, 0
br i1 %472, label %473, label %482
473: ; preds = %466
%474 = load i8*, i8** %5
%475 = load i8*, i8** %4
%476 = icmp uge i8* %474, %475
br i1 %476, label %477, label %478
477: ; preds = %473
br label %1191
478: ; preds = %473
%479 = load i8*, i8** %5
%480 = bitcast i8* %479 to i64*
%481 = load i64, i64* %480
store i64 %481, i64* %7
br label %482
482: ; preds = %478, %466
%483 = load i8*, i8** %5
%484 = getelementptr inbounds i8, i8* %483, i32 1
store i8* %484, i8** %5
%485 = load i64, i64* %7
%486 = lshr i64 %485, 56
%487 = icmp eq i64 %486, 32
br i1 %487, label %488, label %489
488: ; preds = %482
br label %466
489: ; preds = %482
%490 = load i64, i64* %7
%491 = lshr i64 %490, 56
%492 = icmp eq i64 %491, 9
br i1 %492, label %493, label %494
493: ; preds = %489
br label %466
494: ; preds = %489
%495 = load i8*, i8** %5
store i8* %495, i8** %6
%496 = load i64, i64* %7
%497 = lshr i64 %496, 56
%498 = icmp eq i64 %497, 34
br i1 %498, label %499, label %500
499: ; preds = %494
br label %506
500: ; preds = %494
%501 = load i64, i64* %7
%502 = lshr i64 %501, 56
%503 = icmp eq i64 %502, 60
br i1 %503, label %504, label %505
504: ; preds = %500
br label %544
505: ; preds = %500
br label %29
506: ; preds = %533, %499
%507 = load i64, i64* %7
%508 = shl i64 %507, 8
store i64 %508, i64* %7
%509 = load i8*, i8** %5
%510 = ptrtoint i8* %509 to i64
%511 = urem i64 %510, 8
%512 = icmp eq i64 %511, 0
br i1 %512, label %513, label %522
513: ; preds = %506
%514 = load i8*, i8** %5
%515 = load i8*, i8** %4
%516 = icmp uge i8* %514, %515
br i1 %516, label %517, label %518
517: ; preds = %513
br label %1191
518: ; preds = %513
%519 = load i8*, i8** %5
%520 = bitcast i8* %519 to i64*
%521 = load i64, i64* %520
store i64 %521, i64* %7
br label %522
522: ; preds = %518, %506
%523 = load i8*, i8** %5
%524 = getelementptr inbounds i8, i8* %523, i32 1
store i8* %524, i8** %5
%525 = load i64, i64* %7
%526 = lshr i64 %525, 56
%527 = icmp eq i64 %526, 10
br i1 %527, label %528, label %529
528: ; preds = %522
br label %10
529: ; preds = %522
%530 = load i64, i64* %7
%531 = lshr i64 %530, 56
%532 = icmp ne i64 %531, 34
br i1 %532, label %533, label %534
533: ; preds = %529
br label %506
534: ; preds = %529
%535 = load i8*, i8** %6
%536 = load i8*, i8** %5
%537 = load i8*, i8** %6
%538 = ptrtoint i8* %536 to i64
%539 = ptrtoint i8* %537 to i64
%540 = sub i64 %538, %539
%541 = sub nsw i64 %540, 1
%542 = trunc i64 %541 to i32
%543 = call i32 @handle_include(i32 0, i8* %535, i32 %542)
br label %10
544: ; preds = %571, %504
%545 = load i64, i64* %7
%546 = shl i64 %545, 8
store i64 %546, i64* %7
%547 = load i8*, i8** %5
%548 = ptrtoint i8* %547 to i64
%549 = urem i64 %548, 8
%550 = icmp eq i64 %549, 0
br i1 %550, label %551, label %560
551: ; preds = %544
%552 = load i8*, i8** %5
%553 = load i8*, i8** %4
%554 = icmp uge i8* %552, %553
br i1 %554, label %555, label %556
555: ; preds = %551
br label %1191
556: ; preds = %551
%557 = load i8*, i8** %5
%558 = bitcast i8* %557 to i64*
%559 = load i64, i64* %558
store i64 %559, i64* %7
br label %560
560: ; preds = %556, %544
%561 = load i8*, i8** %5
%562 = getelementptr inbounds i8, i8* %561, i32 1
store i8* %562, i8** %5
%563 = load i64, i64* %7
%564 = lshr i64 %563, 56
%565 = icmp eq i64 %564, 10
br i1 %565, label %566, label %567
566: ; preds = %560
br label %10
567: ; preds = %560
%568 = load i64, i64* %7
%569 = lshr i64 %568, 56
%570 = icmp ne i64 %569, 62
br i1 %570, label %571, label %572
571: ; preds = %567
br label %544
572: ; preds = %567
%573 = load i8*, i8** %6
%574 = load i8*, i8** %5
%575 = load i8*, i8** %6
%576 = ptrtoint i8* %574 to i64
%577 = ptrtoint i8* %575 to i64
%578 = sub i64 %576, %577
%579 = sub nsw i64 %578, 1
%580 = trunc i64 %579 to i32
%581 = call i32 @handle_include(i32 1, i8* %573, i32 %580)
br label %10
582: ; preds = %320
%583 = load i64, i64* %7
%584 = shl i64 %583, 8
store i64 %584, i64* %7
%585 = load i8*, i8** %5
%586 = ptrtoint i8* %585 to i64
%587 = urem i64 %586, 8
%588 = icmp eq i64 %587, 0
br i1 %588, label %589, label %598
589: ; preds = %582
%590 = load i8*, i8** %5
%591 = load i8*, i8** %4
%592 = icmp uge i8* %590, %591
br i1 %592, label %593, label %594
593: ; preds = %589
br label %1191
594: ; preds = %589
%595 = load i8*, i8** %5
%596 = bitcast i8* %595 to i64*
%597 = load i64, i64* %596
store i64 %597, i64* %7
br label %598
598: ; preds = %594, %582
%599 = load i8*, i8** %5
%600 = getelementptr inbounds i8, i8* %599, i32 1
store i8* %600, i8** %5
%601 = load i64, i64* %7
%602 = lshr i64 %601, 56
%603 = icmp ne i64 %602, 101
br i1 %603, label %604, label %605
604: ; preds = %598
br label %29
605: ; preds = %598
%606 = load i64, i64* %7
%607 = shl i64 %606, 8
store i64 %607, i64* %7
%608 = load i8*, i8** %5
%609 = ptrtoint i8* %608 to i64
%610 = urem i64 %609, 8
%611 = icmp eq i64 %610, 0
br i1 %611, label %612, label %621
612: ; preds = %605
%613 = load i8*, i8** %5
%614 = load i8*, i8** %4
%615 = icmp uge i8* %613, %614
br i1 %615, label %616, label %617
616: ; preds = %612
br label %1191
617: ; preds = %612
%618 = load i8*, i8** %5
%619 = bitcast i8* %618 to i64*
%620 = load i64, i64* %619
store i64 %620, i64* %7
br label %621
621: ; preds = %617, %605
%622 = load i8*, i8** %5
%623 = getelementptr inbounds i8, i8* %622, i32 1
store i8* %623, i8** %5
%624 = load i64, i64* %7
%625 = lshr i64 %624, 56
%626 = icmp ne i64 %625, 102
br i1 %626, label %627, label %628
627: ; preds = %621
br label %29
628: ; preds = %621
%629 = load i64, i64* %7
%630 = shl i64 %629, 8
store i64 %630, i64* %7
%631 = load i8*, i8** %5
%632 = ptrtoint i8* %631 to i64
%633 = urem i64 %632, 8
%634 = icmp eq i64 %633, 0
br i1 %634, label %635, label %644
635: ; preds = %628
%636 = load i8*, i8** %5
%637 = load i8*, i8** %4
%638 = icmp uge i8* %636, %637
br i1 %638, label %639, label %640
639: ; preds = %635
br label %1191
640: ; preds = %635
%641 = load i8*, i8** %5
%642 = bitcast i8* %641 to i64*
%643 = load i64, i64* %642
store i64 %643, i64* %7
br label %644
644: ; preds = %640, %628
%645 = load i8*, i8** %5
%646 = getelementptr inbounds i8, i8* %645, i32 1
store i8* %646, i8** %5
%647 = load i64, i64* %7
%648 = lshr i64 %647, 56
%649 = icmp ne i64 %648, 105
br i1 %649, label %650, label %651
650: ; preds = %644
br label %29
651: ; preds = %644
%652 = load i64, i64* %7
%653 = shl i64 %652, 8
store i64 %653, i64* %7
%654 = load i8*, i8** %5
%655 = ptrtoint i8* %654 to i64
%656 = urem i64 %655, 8
%657 = icmp eq i64 %656, 0
br i1 %657, label %658, label %667
658: ; preds = %651
%659 = load i8*, i8** %5
%660 = load i8*, i8** %4
%661 = icmp uge i8* %659, %660
br i1 %661, label %662, label %663
662: ; preds = %658
br label %1191
663: ; preds = %658
%664 = load i8*, i8** %5
%665 = bitcast i8* %664 to i64*
%666 = load i64, i64* %665
store i64 %666, i64* %7
br label %667
667: ; preds = %663, %651
%668 = load i8*, i8** %5
%669 = getelementptr inbounds i8, i8* %668, i32 1
store i8* %669, i8** %5
%670 = load i64, i64* %7
%671 = lshr i64 %670, 56
%672 = icmp ne i64 %671, 110
br i1 %672, label %673, label %674
673: ; preds = %667
br label %29
674: ; preds = %667
%675 = load i64, i64* %7
%676 = shl i64 %675, 8
store i64 %676, i64* %7
%677 = load i8*, i8** %5
%678 = ptrtoint i8* %677 to i64
%679 = urem i64 %678, 8
%680 = icmp eq i64 %679, 0
br i1 %680, label %681, label %690
681: ; preds = %674
%682 = load i8*, i8** %5
%683 = load i8*, i8** %4
%684 = icmp uge i8* %682, %683
br i1 %684, label %685, label %686
685: ; preds = %681
br label %1191
686: ; preds = %681
%687 = load i8*, i8** %5
%688 = bitcast i8* %687 to i64*
%689 = load i64, i64* %688
store i64 %689, i64* %7
br label %690
690: ; preds = %686, %674
%691 = load i8*, i8** %5
%692 = getelementptr inbounds i8, i8* %691, i32 1
store i8* %692, i8** %5
%693 = load i64, i64* %7
%694 = lshr i64 %693, 56
%695 = icmp ne i64 %694, 101
br i1 %695, label %696, label %697
696: ; preds = %690
br label %29
697: ; preds = %690
br label %791
698: ; preds = %325
%699 = load i64, i64* %7
%700 = shl i64 %699, 8
store i64 %700, i64* %7
%701 = load i8*, i8** %5
%702 = ptrtoint i8* %701 to i64
%703 = urem i64 %702, 8
%704 = icmp eq i64 %703, 0
br i1 %704, label %705, label %714
705: ; preds = %698
%706 = load i8*, i8** %5
%707 = load i8*, i8** %4
%708 = icmp uge i8* %706, %707
br i1 %708, label %709, label %710
709: ; preds = %705
br label %1191
710: ; preds = %705
%711 = load i8*, i8** %5
%712 = bitcast i8* %711 to i64*
%713 = load i64, i64* %712
store i64 %713, i64* %7
br label %714
714: ; preds = %710, %698
%715 = load i8*, i8** %5
%716 = getelementptr inbounds i8, i8* %715, i32 1
store i8* %716, i8** %5
%717 = load i64, i64* %7
%718 = lshr i64 %717, 56
%719 = icmp ne i64 %718, 110
br i1 %719, label %720, label %721
720: ; preds = %714
br label %29
721: ; preds = %714
%722 = load i64, i64* %7
%723 = shl i64 %722, 8
store i64 %723, i64* %7
%724 = load i8*, i8** %5
%725 = ptrtoint i8* %724 to i64
%726 = urem i64 %725, 8
%727 = icmp eq i64 %726, 0
br i1 %727, label %728, label %737
728: ; preds = %721
%729 = load i8*, i8** %5
%730 = load i8*, i8** %4
%731 = icmp uge i8* %729, %730
br i1 %731, label %732, label %733
732: ; preds = %728
br label %1191
733: ; preds = %728
%734 = load i8*, i8** %5
%735 = bitcast i8* %734 to i64*
%736 = load i64, i64* %735
store i64 %736, i64* %7
br label %737
737: ; preds = %733, %721
%738 = load i8*, i8** %5
%739 = getelementptr inbounds i8, i8* %738, i32 1
store i8* %739, i8** %5
%740 = load i64, i64* %7
%741 = lshr i64 %740, 56
%742 = icmp ne i64 %741, 100
br i1 %742, label %743, label %744
743: ; preds = %737
br label %29
744: ; preds = %737
%745 = load i64, i64* %7
%746 = shl i64 %745, 8
store i64 %746, i64* %7
%747 = load i8*, i8** %5
%748 = ptrtoint i8* %747 to i64
%749 = urem i64 %748, 8
%750 = icmp eq i64 %749, 0
br i1 %750, label %751, label %760
751: ; preds = %744
%752 = load i8*, i8** %5
%753 = load i8*, i8** %4
%754 = icmp uge i8* %752, %753
br i1 %754, label %755, label %756
755: ; preds = %751
br label %1191
756: ; preds = %751
%757 = load i8*, i8** %5
%758 = bitcast i8* %757 to i64*
%759 = load i64, i64* %758
store i64 %759, i64* %7
br label %760
760: ; preds = %756, %744
%761 = load i8*, i8** %5
%762 = getelementptr inbounds i8, i8* %761, i32 1
store i8* %762, i8** %5
%763 = load i64, i64* %7
%764 = lshr i64 %763, 56
%765 = icmp ne i64 %764, 101
br i1 %765, label %766, label %767
766: ; preds = %760
br label %29
767: ; preds = %760
%768 = load i64, i64* %7
%769 = shl i64 %768, 8
store i64 %769, i64* %7
%770 = load i8*, i8** %5
%771 = ptrtoint i8* %770 to i64
%772 = urem i64 %771, 8
%773 = icmp eq i64 %772, 0
br i1 %773, label %774, label %783
774: ; preds = %767
%775 = load i8*, i8** %5
%776 = load i8*, i8** %4
%777 = icmp uge i8* %775, %776
br i1 %777, label %778, label %779
778: ; preds = %774
br label %1191
779: ; preds = %774
%780 = load i8*, i8** %5
%781 = bitcast i8* %780 to i64*
%782 = load i64, i64* %781
store i64 %782, i64* %7
br label %783
783: ; preds = %779, %767
%784 = load i8*, i8** %5
%785 = getelementptr inbounds i8, i8* %784, i32 1
store i8* %785, i8** %5
%786 = load i64, i64* %7
%787 = lshr i64 %786, 56
%788 = icmp ne i64 %787, 102
br i1 %788, label %789, label %790
789: ; preds = %783
br label %29
790: ; preds = %783
br label %791
791: ; preds = %818, %813, %790, %697
%792 = load i64, i64* %7
%793 = shl i64 %792, 8
store i64 %793, i64* %7
%794 = load i8*, i8** %5
%795 = ptrtoint i8* %794 to i64
%796 = urem i64 %795, 8
%797 = icmp eq i64 %796, 0
br i1 %797, label %798, label %807
798: ; preds = %791
%799 = load i8*, i8** %5
%800 = load i8*, i8** %4
%801 = icmp uge i8* %799, %800
br i1 %801, label %802, label %803
802: ; preds = %798
br label %1191
803: ; preds = %798
%804 = load i8*, i8** %5
%805 = bitcast i8* %804 to i64*
%806 = load i64, i64* %805
store i64 %806, i64* %7
br label %807
807: ; preds = %803, %791
%808 = load i8*, i8** %5
%809 = getelementptr inbounds i8, i8* %808, i32 1
store i8* %809, i8** %5
%810 = load i64, i64* %7
%811 = lshr i64 %810, 56
%812 = icmp eq i64 %811, 32
br i1 %812, label %813, label %814
813: ; preds = %807
br label %791
814: ; preds = %807
%815 = load i64, i64* %7
%816 = lshr i64 %815, 56
%817 = icmp eq i64 %816, 9
br i1 %817, label %818, label %819
818: ; preds = %814
br label %791
819: ; preds = %814
%820 = load i64, i64* %7
%821 = lshr i64 %820, 56
%822 = icmp ne i64 %821, 67
br i1 %822, label %823, label %824
823: ; preds = %819
br label %29
824: ; preds = %819
%825 = load i64, i64* %7
%826 = shl i64 %825, 8
store i64 %826, i64* %7
%827 = load i8*, i8** %5
%828 = ptrtoint i8* %827 to i64
%829 = urem i64 %828, 8
%830 = icmp eq i64 %829, 0
br i1 %830, label %831, label %840
831: ; preds = %824
%832 = load i8*, i8** %5
%833 = load i8*, i8** %4
%834 = icmp uge i8* %832, %833
br i1 %834, label %835, label %836
835: ; preds = %831
br label %1191
836: ; preds = %831
%837 = load i8*, i8** %5
%838 = bitcast i8* %837 to i64*
%839 = load i64, i64* %838
store i64 %839, i64* %7
br label %840
840: ; preds = %836, %824
%841 = load i8*, i8** %5
%842 = getelementptr inbounds i8, i8* %841, i32 1
store i8* %842, i8** %5
%843 = load i64, i64* %7
%844 = lshr i64 %843, 56
%845 = icmp ne i64 %844, 79
br i1 %845, label %846, label %847
846: ; preds = %840
br label %29
847: ; preds = %840
%848 = load i64, i64* %7
%849 = shl i64 %848, 8
store i64 %849, i64* %7
%850 = load i8*, i8** %5
%851 = ptrtoint i8* %850 to i64
%852 = urem i64 %851, 8
%853 = icmp eq i64 %852, 0
br i1 %853, label %854, label %863
854: ; preds = %847
%855 = load i8*, i8** %5
%856 = load i8*, i8** %4
%857 = icmp uge i8* %855, %856
br i1 %857, label %858, label %859
858: ; preds = %854
br label %1191
859: ; preds = %854
%860 = load i8*, i8** %5
%861 = bitcast i8* %860 to i64*
%862 = load i64, i64* %861
store i64 %862, i64* %7
br label %863
863: ; preds = %859, %847
%864 = load i8*, i8** %5
%865 = getelementptr inbounds i8, i8* %864, i32 1
store i8* %865, i8** %5
%866 = load i64, i64* %7
%867 = lshr i64 %866, 56
%868 = icmp ne i64 %867, 78
br i1 %868, label %869, label %870
869: ; preds = %863
br label %29
870: ; preds = %863
%871 = load i64, i64* %7
%872 = shl i64 %871, 8
store i64 %872, i64* %7
%873 = load i8*, i8** %5
%874 = ptrtoint i8* %873 to i64
%875 = urem i64 %874, 8
%876 = icmp eq i64 %875, 0
br i1 %876, label %877, label %886
877: ; preds = %870
%878 = load i8*, i8** %5
%879 = load i8*, i8** %4
%880 = icmp uge i8* %878, %879
br i1 %880, label %881, label %882
881: ; preds = %877
br label %1191
882: ; preds = %877
%883 = load i8*, i8** %5
%884 = bitcast i8* %883 to i64*
%885 = load i64, i64* %884
store i64 %885, i64* %7
br label %886
886: ; preds = %882, %870
%887 = load i8*, i8** %5
%888 = getelementptr inbounds i8, i8* %887, i32 1
store i8* %888, i8** %5
%889 = load i64, i64* %7
%890 = lshr i64 %889, 56
%891 = icmp ne i64 %890, 70
br i1 %891, label %892, label %893
892: ; preds = %886
br label %29
893: ; preds = %886
%894 = load i64, i64* %7
%895 = shl i64 %894, 8
store i64 %895, i64* %7
%896 = load i8*, i8** %5
%897 = ptrtoint i8* %896 to i64
%898 = urem i64 %897, 8
%899 = icmp eq i64 %898, 0
br i1 %899, label %900, label %909
900: ; preds = %893
%901 = load i8*, i8** %5
%902 = load i8*, i8** %4
%903 = icmp uge i8* %901, %902
br i1 %903, label %904, label %905
904: ; preds = %900
br label %1191
905: ; preds = %900
%906 = load i8*, i8** %5
%907 = bitcast i8* %906 to i64*
%908 = load i64, i64* %907
store i64 %908, i64* %7
br label %909
909: ; preds = %905, %893
%910 = load i8*, i8** %5
%911 = getelementptr inbounds i8, i8* %910, i32 1
store i8* %911, i8** %5
%912 = load i64, i64* %7
%913 = lshr i64 %912, 56
%914 = icmp ne i64 %913, 73
br i1 %914, label %915, label %916
915: ; preds = %909
br label %29
916: ; preds = %909
%917 = load i64, i64* %7
%918 = shl i64 %917, 8
store i64 %918, i64* %7
%919 = load i8*, i8** %5
%920 = ptrtoint i8* %919 to i64
%921 = urem i64 %920, 8
%922 = icmp eq i64 %921, 0
br i1 %922, label %923, label %932
923: ; preds = %916
%924 = load i8*, i8** %5
%925 = load i8*, i8** %4
%926 = icmp uge i8* %924, %925
br i1 %926, label %927, label %928
927: ; preds = %923
br label %1191
928: ; preds = %923
%929 = load i8*, i8** %5
%930 = bitcast i8* %929 to i64*
%931 = load i64, i64* %930
store i64 %931, i64* %7
br label %932
932: ; preds = %928, %916
%933 = load i8*, i8** %5
%934 = getelementptr inbounds i8, i8* %933, i32 1
store i8* %934, i8** %5
%935 = load i64, i64* %7
%936 = lshr i64 %935, 56
%937 = icmp ne i64 %936, 71
br i1 %937, label %938, label %939
938: ; preds = %932
br label %29
939: ; preds = %932
%940 = load i64, i64* %7
%941 = shl i64 %940, 8
store i64 %941, i64* %7
%942 = load i8*, i8** %5
%943 = ptrtoint i8* %942 to i64
%944 = urem i64 %943, 8
%945 = icmp eq i64 %944, 0
br i1 %945, label %946, label %955
946: ; preds = %939
%947 = load i8*, i8** %5
%948 = load i8*, i8** %4
%949 = icmp uge i8* %947, %948
br i1 %949, label %950, label %951
950: ; preds = %946
br label %1191
951: ; preds = %946
%952 = load i8*, i8** %5
%953 = bitcast i8* %952 to i64*
%954 = load i64, i64* %953
store i64 %954, i64* %7
br label %955
955: ; preds = %951, %939
%956 = load i8*, i8** %5
%957 = getelementptr inbounds i8, i8* %956, i32 1
store i8* %957, i8** %5
%958 = load i64, i64* %7
%959 = lshr i64 %958, 56
%960 = icmp ne i64 %959, 95
br i1 %960, label %961, label %962
961: ; preds = %955
br label %29
962: ; preds = %955
%963 = load i8*, i8** %5
store i8* %963, i8** %6
br label %964
964: ; preds = %992, %962
%965 = load i64, i64* %7
%966 = shl i64 %965, 8
store i64 %966, i64* %7
%967 = load i8*, i8** %5
%968 = ptrtoint i8* %967 to i64
%969 = urem i64 %968, 8
%970 = icmp eq i64 %969, 0
br i1 %970, label %971, label %980
971: ; preds = %964
%972 = load i8*, i8** %5
%973 = load i8*, i8** %4
%974 = icmp uge i8* %972, %973
br i1 %974, label %975, label %976
975: ; preds = %971
br label %1191
976: ; preds = %971
%977 = load i8*, i8** %5
%978 = bitcast i8* %977 to i64*
%979 = load i64, i64* %978
store i64 %979, i64* %7
br label %980
980: ; preds = %976, %964
%981 = load i8*, i8** %5
%982 = getelementptr inbounds i8, i8* %981, i32 1
store i8* %982, i8** %5
%983 = load i64, i64* %7
%984 = lshr i64 %983, 56
%985 = trunc i64 %984 to i8
%986 = call i64 @isalnum(i8 signext %985)
%987 = icmp ne i64 %986, 0
br i1 %987, label %992, label %988
988: ; preds = %980
%989 = load i64, i64* %7
%990 = lshr i64 %989, 56
%991 = icmp eq i64 %990, 95
br i1 %991, label %992, label %993
992: ; preds = %988, %980
br label %964
993: ; preds = %988
br label %29
994: ; preds = %63
%995 = load i8*, i8** %5
%996 = load i8*, i8** %3
%997 = getelementptr inbounds i8, i8* %996, i64 2
%998 = icmp uge i8* %995, %997
br i1 %998, label %999, label %1012
999: ; preds = %994
%1000 = load i8*, i8** %5
%1001 = getelementptr inbounds i8, i8* %1000, i64 -2
%1002 = load i8, i8* %1001
%1003 = call i64 @isalnum(i8 signext %1002)
%1004 = icmp ne i64 %1003, 0
br i1 %1004, label %1011, label %1005
1005: ; preds = %999
%1006 = load i8*, i8** %5
%1007 = getelementptr inbounds i8, i8* %1006, i64 -2
%1008 = load i8, i8* %1007
%1009 = sext i8 %1008 to i32
%1010 = icmp eq i32 %1009, 95
br i1 %1010, label %1011, label %1012
1011: ; preds = %1005, %999
br label %10
1012: ; preds = %1005, %994
%1013 = load i64, i64* %7
%1014 = shl i64 %1013, 8
store i64 %1014, i64* %7
%1015 = load i8*, i8** %5
%1016 = ptrtoint i8* %1015 to i64
%1017 = urem i64 %1016, 8
%1018 = icmp eq i64 %1017, 0
br i1 %1018, label %1019, label %1028
1019: ; preds = %1012
%1020 = load i8*, i8** %5
%1021 = load i8*, i8** %4
%1022 = icmp uge i8* %1020, %1021
br i1 %1022, label %1023, label %1024
1023: ; preds = %1019
br label %1191
1024: ; preds = %1019
%1025 = load i8*, i8** %5
%1026 = bitcast i8* %1025 to i64*
%1027 = load i64, i64* %1026
store i64 %1027, i64* %7
br label %1028
1028: ; preds = %1024, %1012
%1029 = load i8*, i8** %5
%1030 = getelementptr inbounds i8, i8* %1029, i32 1
store i8* %1030, i8** %5
%1031 = load i64, i64* %7
%1032 = lshr i64 %1031, 56
%1033 = icmp ne i64 %1032, 79
br i1 %1033, label %1034, label %1035
1034: ; preds = %1028
br label %29
1035: ; preds = %1028
%1036 = load i64, i64* %7
%1037 = shl i64 %1036, 8
store i64 %1037, i64* %7
%1038 = load i8*, i8** %5
%1039 = ptrtoint i8* %1038 to i64
%1040 = urem i64 %1039, 8
%1041 = icmp eq i64 %1040, 0
br i1 %1041, label %1042, label %1051
1042: ; preds = %1035
%1043 = load i8*, i8** %5
%1044 = load i8*, i8** %4
%1045 = icmp uge i8* %1043, %1044
br i1 %1045, label %1046, label %1047
1046: ; preds = %1042
br label %1191
1047: ; preds = %1042
%1048 = load i8*, i8** %5
%1049 = bitcast i8* %1048 to i64*
%1050 = load i64, i64* %1049
store i64 %1050, i64* %7
br label %1051
1051: ; preds = %1047, %1035
%1052 = load i8*, i8** %5
%1053 = getelementptr inbounds i8, i8* %1052, i32 1
store i8* %1053, i8** %5
%1054 = load i64, i64* %7
%1055 = lshr i64 %1054, 56
%1056 = icmp ne i64 %1055, 78
br i1 %1056, label %1057, label %1058
1057: ; preds = %1051
br label %29
1058: ; preds = %1051
%1059 = load i64, i64* %7
%1060 = shl i64 %1059, 8
store i64 %1060, i64* %7
%1061 = load i8*, i8** %5
%1062 = ptrtoint i8* %1061 to i64
%1063 = urem i64 %1062, 8
%1064 = icmp eq i64 %1063, 0
br i1 %1064, label %1065, label %1074
1065: ; preds = %1058
%1066 = load i8*, i8** %5
%1067 = load i8*, i8** %4
%1068 = icmp uge i8* %1066, %1067
br i1 %1068, label %1069, label %1070
1069: ; preds = %1065
br label %1191
1070: ; preds = %1065
%1071 = load i8*, i8** %5
%1072 = bitcast i8* %1071 to i64*
%1073 = load i64, i64* %1072
store i64 %1073, i64* %7
br label %1074
1074: ; preds = %1070, %1058
%1075 = load i8*, i8** %5
%1076 = getelementptr inbounds i8, i8* %1075, i32 1
store i8* %1076, i8** %5
%1077 = load i64, i64* %7
%1078 = lshr i64 %1077, 56
%1079 = icmp ne i64 %1078, 70
br i1 %1079, label %1080, label %1081
1080: ; preds = %1074
br label %29
1081: ; preds = %1074
%1082 = load i64, i64* %7
%1083 = shl i64 %1082, 8
store i64 %1083, i64* %7
%1084 = load i8*, i8** %5
%1085 = ptrtoint i8* %1084 to i64
%1086 = urem i64 %1085, 8
%1087 = icmp eq i64 %1086, 0
br i1 %1087, label %1088, label %1097
1088: ; preds = %1081
%1089 = load i8*, i8** %5
%1090 = load i8*, i8** %4
%1091 = icmp uge i8* %1089, %1090
br i1 %1091, label %1092, label %1093
1092: ; preds = %1088
br label %1191
1093: ; preds = %1088
%1094 = load i8*, i8** %5
%1095 = bitcast i8* %1094 to i64*
%1096 = load i64, i64* %1095
store i64 %1096, i64* %7
br label %1097
1097: ; preds = %1093, %1081
%1098 = load i8*, i8** %5
%1099 = getelementptr inbounds i8, i8* %1098, i32 1
store i8* %1099, i8** %5
%1100 = load i64, i64* %7
%1101 = lshr i64 %1100, 56
%1102 = icmp ne i64 %1101, 73
br i1 %1102, label %1103, label %1104
1103: ; preds = %1097
br label %29
1104: ; preds = %1097
%1105 = load i64, i64* %7
%1106 = shl i64 %1105, 8
store i64 %1106, i64* %7
%1107 = load i8*, i8** %5
%1108 = ptrtoint i8* %1107 to i64
%1109 = urem i64 %1108, 8
%1110 = icmp eq i64 %1109, 0
br i1 %1110, label %1111, label %1120
1111: ; preds = %1104
%1112 = load i8*, i8** %5
%1113 = load i8*, i8** %4
%1114 = icmp uge i8* %1112, %1113
br i1 %1114, label %1115, label %1116
1115: ; preds = %1111
br label %1191
1116: ; preds = %1111
%1117 = load i8*, i8** %5
%1118 = bitcast i8* %1117 to i64*
%1119 = load i64, i64* %1118
store i64 %1119, i64* %7
br label %1120
1120: ; preds = %1116, %1104
%1121 = load i8*, i8** %5
%1122 = getelementptr inbounds i8, i8* %1121, i32 1
store i8* %1122, i8** %5
%1123 = load i64, i64* %7
%1124 = lshr i64 %1123, 56
%1125 = icmp ne i64 %1124, 71
br i1 %1125, label %1126, label %1127
1126: ; preds = %1120
br label %29
1127: ; preds = %1120
%1128 = load i64, i64* %7
%1129 = shl i64 %1128, 8
store i64 %1129, i64* %7
%1130 = load i8*, i8** %5
%1131 = ptrtoint i8* %1130 to i64
%1132 = urem i64 %1131, 8
%1133 = icmp eq i64 %1132, 0
br i1 %1133, label %1134, label %1143
1134: ; preds = %1127
%1135 = load i8*, i8** %5
%1136 = load i8*, i8** %4
%1137 = icmp uge i8* %1135, %1136
br i1 %1137, label %1138, label %1139
1138: ; preds = %1134
br label %1191
1139: ; preds = %1134
%1140 = load i8*, i8** %5
%1141 = bitcast i8* %1140 to i64*
%1142 = load i64, i64* %1141
store i64 %1142, i64* %7
br label %1143
1143: ; preds = %1139, %1127
%1144 = load i8*, i8** %5
%1145 = getelementptr inbounds i8, i8* %1144, i32 1
store i8* %1145, i8** %5
%1146 = load i64, i64* %7
%1147 = lshr i64 %1146, 56
%1148 = icmp ne i64 %1147, 95
br i1 %1148, label %1149, label %1150
1149: ; preds = %1143
br label %29
1150: ; preds = %1143
%1151 = load i8*, i8** %5
store i8* %1151, i8** %6
br label %1152
1152: ; preds = %1180, %1150
%1153 = load i64, i64* %7
%1154 = shl i64 %1153, 8
store i64 %1154, i64* %7
%1155 = load i8*, i8** %5
%1156 = ptrtoint i8* %1155 to i64
%1157 = urem i64 %1156, 8
%1158 = icmp eq i64 %1157, 0
br i1 %1158, label %1159, label %1168
1159: ; preds = %1152
%1160 = load i8*, i8** %5
%1161 = load i8*, i8** %4
%1162 = icmp uge i8* %1160, %1161
br i1 %1162, label %1163, label %1164
1163: ; preds = %1159
br label %1191
1164: ; preds = %1159
%1165 = load i8*, i8** %5
%1166 = bitcast i8* %1165 to i64*
%1167 = load i64, i64* %1166
store i64 %1167, i64* %7
br label %1168
1168: ; preds = %1164, %1152
%1169 = load i8*, i8** %5
%1170 = getelementptr inbounds i8, i8* %1169, i32 1
store i8* %1170, i8** %5
%1171 = load i64, i64* %7
%1172 = lshr i64 %1171, 56
%1173 = trunc i64 %1172 to i8
%1174 = call i64 @isalnum(i8 signext %1173)
%1175 = icmp ne i64 %1174, 0
br i1 %1175, label %1180, label %1176
1176: ; preds = %1168
%1177 = load i64, i64* %7
%1178 = lshr i64 %1177, 56
%1179 = icmp eq i64 %1178, 95
br i1 %1179, label %1180, label %1181
1180: ; preds = %1176, %1168
br label %1152
1181: ; preds = %1176
%1182 = load i8*, i8** %6
%1183 = load i8*, i8** %5
%1184 = load i8*, i8** %6
%1185 = ptrtoint i8* %1183 to i64
%1186 = ptrtoint i8* %1184 to i64
%1187 = sub i64 %1185, %1186
%1188 = sub nsw i64 %1187, 1
%1189 = trunc i64 %1188 to i32
%1190 = call i32 @use_config(i8* %1182, i32 %1189)
br label %29
1191: ; preds = %1163, %1138, %1115, %1092, %1069, %1046, %1023, %975, %950, %927, %904, %881, %858, %835, %802, %778, %755, %732, %709, %685, %662, %639, %616, %593, %555, %517, %477, %453, %430, %407, %384, %361, %338, %294, %275, %247, %228, %200, %176, %152, %123, %104, %76, %21
ret void
}

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