#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*/ error(char *, char *, ...);
int /*<<< orphan*/ exit(int);
scalar_t__ is_separator(char *);
void *malloc(unsigned int);
scalar_t__ strcmp(char *, char *);
void analyze(char **lines, unsigned int length) {
  char **automaton_names = malloc(length * sizeof(char *));
  int *automaton_argnums = malloc(length * sizeof(int));
  unsigned int automaton_cnt = 0;
  char **assignment_names = malloc(length * sizeof(char *));
  unsigned int assignment_cnt = 0;
  unsigned int i, ii, iii;
  for (i = 0; i < length; i++) {
    if (lines[i][0] == '@') {
      for (ii = 0; lines[i][ii] != '(' && lines[i][ii] != '\0'; ii++)
        ;
      if (lines[i][ii] == '\0') {
        error("error: missing argument delimiter \'(\' in automaton head "
              "\'%s\'\n",
              lines[i]);
        exit(1);
      }
      char *fname = malloc((ii + 1) * sizeof(char));
      for (iii = 0; iii < ii; iii++) {
        fname[iii] = lines[i][iii];
      }
      fname[ii] = '\0';
      char **arg_names = malloc(128 * sizeof(char *));
      unsigned int arg_cnt = 0;
      unsigned int argstart = ii + 1;
      for (ii = argstart; lines[i][ii] != ')'; ii++) {
        if (lines[i][ii] == ',') {
          char *argname = malloc((ii - argstart + 1) * sizeof(char));
          for (iii = argstart; iii < ii; iii++) {
            argname[iii - argstart] = lines[i][iii];
          }
          argname[iii - argstart] = '\0';
          for (iii = 0; iii < arg_cnt; iii++) {
            if (strcmp(argname, arg_names[iii]) == 0) {
              error("error: multiple declaration of parameter \'%s\' in "
                    "automaton \'%s\'\n",
                    argname, fname);
              exit(1);
            }
          }
          arg_names[arg_cnt] = argname;
          arg_cnt++;
          argstart = ii + 1;
        } else if (lines[i][ii] == '\0') {
          error("error: missing argument delimiter \')\' in automaton head "
                "\'%s\'\n",
                lines[i]);
          exit(1);
        }
      }
      if (lines[i][argstart] != ')') {
        char *argname = malloc((ii - argstart + 1) * sizeof(char));
        for (iii = argstart; iii < ii; iii++) {
          argname[iii - argstart] = lines[i][iii];
        }
        argname[iii - argstart] = '\0';
        for (iii = 0; iii < arg_cnt; iii++) {
          if (strcmp(argname, arg_names[iii]) == 0) {
            error("error: multiple declaration of parameter \'%s\' in "
                  "automaton \'%s\'\n",
                  argname, fname);
            exit(1);
          }
        }
        arg_names[arg_cnt] = argname;
        arg_cnt++;
      }
      for (ii = 0; ii < automaton_cnt; ii++) {
        if (strcmp(fname, automaton_names[ii]) == 0) {
          error("error: multiple declaration of automaton \'%s\'\n", fname);
          exit(1);
        }
      }
      automaton_names[automaton_cnt] = fname;
      automaton_argnums[automaton_cnt] = arg_cnt;
      automaton_cnt++;
      assignment_cnt = 0;
    } else if (is_separator(lines[i])) {
      assignment_cnt = 0;
    } else if (automaton_cnt > 0) {
      char *var;
      ii = 0;
      while (lines[i][ii] != ':' && lines[i][ii] != '\0') {
        ii++;
      }
      var = malloc((ii + 1) * sizeof(char));
      ii = 0;
      while (lines[i][ii] != ':' && lines[i][ii] != '\0') {
        var[ii] = lines[i][ii];
        ii++;
      }
      var[ii] = '\0';
      if (lines[i][ii] == ':') {
        for (ii = 0; ii < assignment_cnt; ii++) {
          if (strcmp(var, assignment_names[ii]) == 0) {
            error("error: multiple assignment to variable \'%s\' within the "
                  "same ruleset in automaton \'%s\'\n",
                  var, automaton_names[automaton_cnt - 1]);
          }
        }
        assignment_names[assignment_cnt] = var;
        assignment_cnt++;
      }
    }
  }
}


x86 assembly (clang, -O0):
<analyze>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    17ef <analyze+0x69f>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x40,%eax
jne    1607 <analyze+0x4b7>
movl   $0x0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x71(%rbp)
je     1212 <analyze+0xc2>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    1222 <analyze+0xd2>
jmp    1235 <analyze+0xe5>
jmp    1227 <analyze+0xd7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d7 <analyze+0x87>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1273 <analyze+0x123>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
lea    0xd9e(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    12c6 <analyze+0x176>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1291 <analyze+0x141>
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    $0x400,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     1475 <analyze+0x325>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    141f <analyze+0x2cf>
mov    -0x3c(%rbp),%eax
sub    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    1385 <analyze+0x235>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x58(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    134b <analyze+0x1fb>
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x58(%rbp),%ecx
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jae    13f9 <analyze+0x2a9>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    13e6 <analyze+0x296>
mov    -0x60(%rbp),%rsi
mov    -0x48(%rbp),%rdx
lea    0xc69(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    13eb <analyze+0x29b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    139c <analyze+0x24c>
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1462 <analyze+0x312>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    145d <analyze+0x30d>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
lea    0xc33(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    1462 <analyze+0x312>
jmp    1467 <analyze+0x317>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12f5 <analyze+0x1a5>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     1576 <analyze+0x426>
mov    -0x3c(%rbp),%eax
sub    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    14ea <analyze+0x39a>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x58(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14b0 <analyze+0x360>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x58(%rbp),%ecx
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jae    155e <analyze+0x40e>
mov    -0x68(%rbp),%rdi
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    154b <analyze+0x3fb>
mov    -0x68(%rbp),%rsi
mov    -0x48(%rbp),%rdx
lea    0xb04(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    1550 <analyze+0x400>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1501 <analyze+0x3b1>
mov    -0x68(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    15d6 <analyze+0x486>
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    15c3 <analyze+0x473>
mov    -0x48(%rbp),%rsi
lea    0xb0b(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
jmp    15c8 <analyze+0x478>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    157d <analyze+0x42d>
mov    -0x48(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    17dc <analyze+0x68c>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rdi
call   1030 <is_separator@plt>
cmp    $0x0,%rax
je     162d <analyze+0x4dd>
movl   $0x0,-0x34(%rbp)
jmp    17d7 <analyze+0x687>
cmpl   $0x0,-0x24(%rbp)
jbe    17d2 <analyze+0x682>
movl   $0x0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3a,%ecx
mov    %al,-0x72(%rbp)
je     1679 <analyze+0x529>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x72(%rbp)
mov    -0x72(%rbp),%al
test   $0x1,%al
jne    1689 <analyze+0x539>
jmp    1697 <analyze+0x547>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    163e <analyze+0x4ee>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3a,%ecx
mov    %al,-0x73(%rbp)
je     16f0 <analyze+0x5a0>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x73(%rbp)
mov    -0x73(%rbp),%al
test   $0x1,%al
jne    1700 <analyze+0x5b0>
jmp    1729 <analyze+0x5d9>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16b5 <analyze+0x565>
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    17cd <analyze+0x67d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    17b5 <analyze+0x665>
mov    -0x70(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    17a2 <analyze+0x652>
mov    -0x70(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rdx
lea    0x951(%rip),%rdi
mov    $0x0,%al
call   1060 <error@plt>
jmp    17a7 <analyze+0x657>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1756 <analyze+0x606>
mov    -0x70(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17d2 <analyze+0x682>
jmp    17d7 <analyze+0x687>
jmp    17dc <analyze+0x68c>
jmp    17e1 <analyze+0x691>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ad <analyze+0x5d>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<analyze>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %esi,%ebx
mov    %rdi,0x30(%rsp)
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
test   %ebx,%ebx
je     1b14 <analyze+0x9c4>
mov    %ebx,%eax
mov    %rax,0x50(%rsp)
xor    %ebx,%ebx
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
mov    %r13,0x38(%rsp)
jmp    11d3 <analyze+0x83>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rdi
call   1030 <is_separator@plt>
test   %rax,%rax
je     127e <analyze+0x12e>
xor    %r14d,%r14d
add    $0x1,%rbx
cmp    0x50(%rsp),%rbx
je     1b14 <analyze+0x9c4>
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,8),%r12
cmpb   $0x40,(%r12)
jne    11b0 <analyze+0x60>
mov    %rbx,0x10(%rsp)
xor    %ebx,%ebx
mov    $0x40,%al
xor    %ebp,%ebp
cmp    $0x28,%al
je     1217 <analyze+0xc7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %al,%al
je     1b23 <analyze+0x9d3>
add    $0x1,%ebp
movzbl (%r12,%rbp,1),%eax
add    $0x1,%bl
cmp    $0x28,%al
jne    1200 <analyze+0xb0>
mov    %ebp,%r14d
lea    0x1(%rbp),%edi
mov    %edi,%r15d
call   1050 <malloc@plt>
test   %ebp,%ebp
je     1510 <analyze+0x3c0>
movb   $0x40,(%rax)
cmp    $0x1,%ebp
je     1510 <analyze+0x3c0>
lea    -0x1(%r14),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     14a1 <analyze+0x351>
lea    0x1(%rax),%rcx
lea    (%r12,%r14,1),%rsi
cmp    %rsi,%rcx
jae    126d <analyze+0x11d>
mov    %rax,%rcx
add    %r14,%rcx
lea    0x1(%r12),%rsi
cmp    %rcx,%rsi
jb     14a1 <analyze+0x351>
cmp    $0x20,%r8
jae    1358 <analyze+0x208>
xor    %ecx,%ecx
jmp    1464 <analyze+0x314>
cmpl   $0x0,0x8(%rsp)
je     1337 <analyze+0x1e7>
mov    0x30(%rsp),%rax
mov    %rbx,0x10(%rsp)
mov    (%rax,%rbx,8),%rbp
mov    $0x1,%edi
nopl   0x0(%rax)
lea    -0x1(%rdi),%eax
movzbl 0x0(%rbp,%rax,1),%eax
test   %al,%al
je     12b5 <analyze+0x165>
cmp    $0x3a,%al
je     12b5 <analyze+0x165>
add    $0x1,%edi
jmp    12a0 <analyze+0x150>
call   1050 <malloc@plt>
mov    %rax,%rbx
xor    %eax,%eax
nop
mov    %eax,%eax
movzbl 0x0(%rbp,%rax,1),%ecx
test   %cl,%cl
je     12d8 <analyze+0x188>
cmp    $0x3a,%cl
je     12d8 <analyze+0x188>
mov    %cl,(%rbx,%rax,1)
add    $0x1,%eax
jmp    12c0 <analyze+0x170>
movb   $0x0,(%rbx,%rax,1)
cmpb   $0x3a,0x0(%rbp,%rax,1)
jne    1b0a <analyze+0x9ba>
test   %r14d,%r14d
je     1343 <analyze+0x1f3>
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%r15d
mov    %r14d,%r12d
xor    %ebp,%ebp
jmp    1309 <analyze+0x1b9>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %rbp,%r12
je     1346 <analyze+0x1f6>
mov    0x40(%rsp),%rax
mov    (%rax,%rbp,8),%rsi
mov    %rbx,%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1300 <analyze+0x1b0>
mov    0x0(%r13,%r15,8),%rdx
lea    0xdc1(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <error@plt>
jmp    1300 <analyze+0x1b0>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    11c4 <analyze+0x74>
xor    %r12d,%r12d
mov    0x40(%rsp),%rax
mov    %rbx,(%rax,%r12,8)
add    $0x1,%r14d
jmp    1b0a <analyze+0x9ba>
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
cmp    $0x60,%rdx
jae    137b <analyze+0x22b>
xor    %edx,%edx
jmp    1402 <analyze+0x2b2>
lea    -0x1(%r14),%rdi
and    $0xffffffffffffffe0,%rdi
add    $0xffffffffffffffe0,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x1(%r12,%rdx,1),%xmm0
movups 0x11(%r12,%rdx,1),%xmm1
movups %xmm0,0x1(%rax,%rdx,1)
movups %xmm1,0x11(%rax,%rdx,1)
movups 0x21(%r12,%rdx,1),%xmm0
movups 0x31(%r12,%rdx,1),%xmm1
movups %xmm0,0x21(%rax,%rdx,1)
movups %xmm1,0x31(%rax,%rdx,1)
movups 0x41(%r12,%rdx,1),%xmm0
movups 0x51(%r12,%rdx,1),%xmm1
movups %xmm0,0x41(%rax,%rdx,1)
movups %xmm1,0x51(%rax,%rdx,1)
movups 0x61(%r12,%rdx,1),%xmm0
movups 0x71(%r12,%rdx,1),%xmm1
movups %xmm0,0x61(%rax,%rdx,1)
movups %xmm1,0x71(%rax,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    13a0 <analyze+0x250>
test   $0x3,%sil
je     1455 <analyze+0x305>
add    $0xff,%bpl
and    $0x60,%bpl
add    $0xe0,%bpl
shr    $0x5,%bpl
add    $0x1,%bpl
movzbl %bpl,%esi
and    $0x3,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rdi
or     $0x1,%rdi
movups (%r12,%rdi,1),%xmm0
movups 0x10(%r12,%rdi,1),%xmm1
movups %xmm0,(%rax,%rdi,1)
movups %xmm1,0x10(%rax,%rdi,1)
add    $0x20,%rdx
add    $0xffffffffffffffff,%rsi
jne    1430 <analyze+0x2e0>
cmp    %rcx,%r8
je     1510 <analyze+0x3c0>
test   $0x18,%r8b
je     149a <analyze+0x34a>
lea    -0x1(%r14),%rbp
mov    %rbp,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1(%r12,%rcx,1),%rdi
mov    %rdi,0x1(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1480 <analyze+0x330>
cmp    %rsi,%rbp
jne    14a1 <analyze+0x351>
jmp    1510 <analyze+0x3c0>
or     $0x1,%rcx
mov    %rcx,%rdx
mov    %r14d,%ecx
sub    %edx,%ecx
mov    %rdx,%rsi
not    %rsi
add    %r14,%rsi
test   $0x3,%cl
je     14d2 <analyze+0x382>
sub    %dl,%bl
movzbl %bl,%ecx
and    $0x3,%ecx
nopl   0x0(%rax)
movzbl (%r12,%rdx,1),%ebx
mov    %bl,(%rax,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    14c0 <analyze+0x370>
cmp    $0x3,%rsi
jb     1510 <analyze+0x3c0>
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rdx,1),%ecx
mov    %cl,(%rax,%rdx,1)
movzbl 0x1(%r12,%rdx,1),%ecx
mov    %cl,0x1(%rax,%rdx,1)
movzbl 0x2(%r12,%rdx,1),%ecx
mov    %cl,0x2(%rax,%rdx,1)
movzbl 0x3(%r12,%rdx,1),%ecx
mov    %cl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    14e0 <analyze+0x390>
nop
mov    %rax,0x18(%rsp)
movb   $0x0,(%rax,%r14,1)
mov    $0x400,%edi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
xor    %edx,%edx
mov    %r15d,%ecx
mov    %r15d,%r13d
mov    %edx,%edx
mov    %rdx,0x28(%rsp)
mov    $0x1,%edi
mov    %ecx,%ebx
nop
mov    %r13d,%r15d
movzbl (%r12,%r15,1),%eax
cmp    $0x29,%al
je     1860 <analyze+0x710>
cmp    $0x2c,%al
je     1570 <analyze+0x420>
test   %al,%al
je     1b2c <analyze+0x9dc>
add    $0x1,%r13d
add    $0x1,%edi
add    $0x1,%bl
jmp    1540 <analyze+0x3f0>
nopl   0x0(%rax,%rax,1)
mov    %ecx,0x4(%rsp)
call   1050 <malloc@plt>
mov    0x4(%rsp),%r8d
mov    %rax,%r14
mov    %r8d,%esi
cmp    %r13d,%r8d
jae    17d2 <analyze+0x682>
mov    %r8d,%r9d
mov    %r15,%r10
sub    %r9,%r10
mov    %r9,%rdi
cmp    $0x8,%r10
jb     1740 <analyze+0x5f0>
lea    (%r12,%r9,1),%r11
lea    (%r12,%r15,1),%rax
cmp    %rax,%r14
jae    15c0 <analyze+0x470>
lea    (%r14,%r10,1),%rax
mov    %r9,%rdi
cmp    %rax,%r11
jb     1740 <analyze+0x5f0>
cmp    $0x20,%r10
jae    15cd <analyze+0x47d>
xor    %edx,%edx
jmp    16f2 <analyze+0x5a2>
mov    %r10,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rax
jae    15f0 <analyze+0x4a0>
xor    %esi,%esi
jmp    1680 <analyze+0x530>
lea    (%r12,%r9,1),%rdi
add    $0x70,%rdi
mov    %r15,%rax
sub    %r9,%rax
and    $0xffffffffffffffe0,%rax
add    $0xffffffffffffffe0,%rax
shr    $0x5,%rax
add    $0x1,%rax
and    $0xfffffffffffffffc,%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x70(%rdi,%rsi,1),%xmm0
movups -0x60(%rdi,%rsi,1),%xmm1
movups %xmm0,(%r14,%rsi,1)
movups %xmm1,0x10(%r14,%rsi,1)
movups -0x50(%rdi,%rsi,1),%xmm0
movups -0x40(%rdi,%rsi,1),%xmm1
movups %xmm0,0x20(%r14,%rsi,1)
movups %xmm1,0x30(%r14,%rsi,1)
movups -0x30(%rdi,%rsi,1),%xmm0
movups -0x20(%rdi,%rsi,1),%xmm1
movups %xmm0,0x40(%r14,%rsi,1)
movups %xmm1,0x50(%r14,%rsi,1)
movups -0x10(%rdi,%rsi,1),%xmm0
movups (%rdi,%rsi,1),%xmm1
movups %xmm0,0x60(%r14,%rsi,1)
movups %xmm1,0x70(%r14,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rax
jne    1620 <analyze+0x4d0>
test   $0x3,%r8b
je     16db <analyze+0x58b>
lea    (%r14,%rsi,1),%rax
add    $0x10,%rax
add    %r9,%rsi
add    %r12,%rsi
add    $0x10,%rsi
mov    %r13d,%ecx
sub    %r9d,%ecx
and    $0x60,%cl
add    $0xe0,%cl
shr    $0x5,%cl
add    $0x1,%cl
movzbl %cl,%edi
and    $0x3,%edi
shl    $0x5,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rsi,%rcx,1),%xmm0
movups (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rax,%rcx,1)
movups %xmm1,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdi
jne    16c0 <analyze+0x570>
mov    %r13d,%esi
cmp    %rdx,%r10
mov    0x4(%rsp),%r8d
je     17d2 <analyze+0x682>
test   $0x18,%r10b
je     1733 <analyze+0x5e3>
mov    %r15,%r8
sub    %r9,%r8
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
lea    (%rax,%r9,1),%rdi
mov    %r15,%rsi
sub    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
nopl   (%rax)
mov    (%r11,%rdx,1),%rcx
mov    %rcx,(%r14,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1710 <analyze+0x5c0>
mov    %r13d,%esi
cmp    %rax,%r8
mov    0x4(%rsp),%r8d
jne    1740 <analyze+0x5f0>
jmp    17d2 <analyze+0x682>
add    %r9,%rdx
mov    %rdx,%rdi
nopl   0x0(%rax)
mov    %r15d,%ecx
sub    %edi,%ecx
mov    %rdi,%rax
not    %rax
add    %r15,%rax
test   $0x3,%cl
je     1782 <analyze+0x632>
mov    %r14,%rcx
sub    %r9,%rcx
sub    %dil,%bl
movzbl %bl,%edx
and    $0x3,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r12,%rdi,1),%ebx
mov    %bl,(%rcx,%rdi,1)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1770 <analyze+0x620>
mov    %r13d,%esi
cmp    $0x3,%rax
jb     17d2 <analyze+0x682>
mov    %r14,%rax
sub    %r9,%rax
add    $0x3,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r12,%rdi,1),%ecx
mov    %cl,-0x3(%rax,%rdi,1)
movzbl 0x1(%r12,%rdi,1),%ecx
mov    %cl,-0x2(%rax,%rdi,1)
movzbl 0x2(%r12,%rdi,1),%ecx
mov    %cl,-0x1(%rax,%rdi,1)
movzbl 0x3(%r12,%rdi,1),%ecx
mov    %cl,(%rax,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%r15
jne    17a0 <analyze+0x650>
mov    %r13d,%esi
sub    %r8d,%esi
movb   $0x0,(%r14,%rsi,1)
cmpq   $0x0,0x28(%rsp)
je     1834 <analyze+0x6e4>
xor    %ebx,%ebx
mov    0x18(%rsp),%r15
mov    0x20(%rsp),%r12
mov    0x28(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbx,8),%rsi
mov    %r14,%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1b38 <analyze+0x9e8>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1800 <analyze+0x6b0>
mov    0x30(%rsp),%rax
mov    0x10(%rsp),%rcx
mov    %rbp,%rdx
mov    (%rax,%rcx,8),%r12
mov    %rbp,%rax
jmp    183b <analyze+0x6eb>
xor    %eax,%eax
mov    0x28(%rsp),%rdx
add    $0x1,%r13d
mov    0x20(%rsp),%rcx
mov    %r14,(%rcx,%rax,8)
add    $0x1,%edx
mov    %r13d,%ecx
jmp    1531 <analyze+0x3e1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%ebp
mov    (%r12,%rbp,1),%r14b
cmp    $0x29,%r14b
je     1aae <analyze+0x95e>
mov    %ecx,0x4(%rsp)
call   1050 <malloc@plt>
mov    0x4(%rsp),%r8d
mov    %r8d,%ecx
cmp    %r13d,%r8d
jae    1a65 <analyze+0x915>
mov    %rax,%r9
mov    %r14b,(%rax)
lea    0x1(%rbp),%rax
cmp    %r15,%rax
je     1a5f <analyze+0x90f>
mov    %rbp,%r10
not    %r10
lea    (%r10,%r15,1),%r14
cmp    $0x8,%r14
jb     19ec <analyze+0x89c>
lea    0x1(%r9),%rcx
lea    (%r12,%rbp,1),%r11
add    $0x1,%r11
lea    (%r12,%r15,1),%rdx
cmp    %rdx,%rcx
jae    18db <analyze+0x78b>
mov    %r9,%rsi
mov    %r15,%rcx
sub    %rbp,%rcx
add    %r9,%rcx
cmp    %rcx,%r11
jb     19ec <analyze+0x89c>
cmp    $0x20,%r14
jae    18e8 <analyze+0x798>
xor    %esi,%esi
jmp    19a3 <analyze+0x853>
mov    %r14,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
mov    %rbp,0x48(%rsp)
je     1963 <analyze+0x813>
lea    (%r12,%rbp,1),%rcx
add    $0x31,%rcx
lea    (%r10,%r15,1),%rdx
and    $0xffffffffffffffe0,%rdx
add    $0xffffffffffffffe0,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
mov    %r9,%rbp
nopl   (%rax)
movups -0x30(%rcx,%rdi,1),%xmm0
movups -0x20(%rcx,%rdi,1),%xmm1
movups %xmm0,0x1(%rbp,%rdi,1)
movups %xmm1,0x11(%rbp,%rdi,1)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,0x21(%rbp,%rdi,1)
movups %xmm1,0x31(%rbp,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1930 <analyze+0x7e0>
jmp    1965 <analyze+0x815>
xor    %edi,%edi
test   $0x1,%r8b
mov    0x48(%rsp),%rbp
je     198f <analyze+0x83f>
add    %rax,%rdi
movups (%r12,%rdi,1),%xmm0
movups 0x10(%r12,%rdi,1),%xmm1
sub    %rbp,%rdi
mov    %r9,%rcx
movups %xmm0,(%r9,%rdi,1)
movups %xmm1,0x10(%r9,%rdi,1)
cmp    %rsi,%r14
mov    0x4(%rsp),%r8d
je     1a5f <analyze+0x90f>
test   $0x18,%r14b
je     19e9 <analyze+0x899>
not    %rbp
add    %r15,%rbp
mov    %rbp,%r14
mov    %rbp,%rcx
and    $0xfffffffffffffff8,%rcx
add    %rcx,%rax
lea    (%r10,%r15,1),%rdx
and    $0xfffffffffffffff8,%rdx
mov    %r9,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r11,%rsi,1),%rdi
mov    %rdi,0x1(%rbp,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    19d0 <analyze+0x880>
cmp    %rcx,%r14
jne    19ec <analyze+0x89c>
jmp    1a5f <analyze+0x90f>
add    %rsi,%rax
mov    %r15d,%ecx
sub    %eax,%ecx
mov    %rax,%rdx
not    %rdx
add    %r15,%rdx
test   $0x3,%cl
je     1a22 <analyze+0x8d2>
lea    (%r10,%r9,1),%rcx
add    $0x1,%rcx
sub    %al,%bl
movzbl %bl,%esi
and    $0x3,%esi
nop
movzbl (%r12,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1a10 <analyze+0x8c0>
cmp    $0x3,%rdx
jb     1a5f <analyze+0x90f>
lea    (%r10,%r9,1),%rcx
add    $0x4,%rcx
movzbl (%r12,%rax,1),%edx
mov    %dl,-0x3(%rcx,%rax,1)
movzbl 0x1(%r12,%rax,1),%edx
mov    %dl,-0x2(%rcx,%rax,1)
movzbl 0x2(%r12,%rax,1),%edx
mov    %dl,-0x1(%rcx,%rax,1)
movzbl 0x3(%r12,%rax,1),%edx
mov    %dl,(%rcx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r15
jne    1a30 <analyze+0x8e0>
mov    %r13d,%ecx
mov    %r9,%rax
sub    %r8d,%ecx
movb   $0x0,(%rax,%rcx,1)
mov    0x28(%rsp),%r14
test   %r14,%r14
mov    %rax,%r15
je     1aa1 <analyze+0x951>
xor    %ebx,%ebx
mov    0x20(%rsp),%rbp
mov    0x0(%rbp,%rbx,8),%rsi
mov    %r15,%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1b62 <analyze+0xa12>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1a80 <analyze+0x930>
jmp    1aa9 <analyze+0x959>
xor    %r14d,%r14d
mov    0x20(%rsp),%rbp
mov    %r15,0x0(%rbp,%r14,8)
mov    0x8(%rsp),%r14
test   %r14d,%r14d
je     1aed <analyze+0x99d>
mov    %r14d,%ebx
xor    %ebp,%ebp
mov    0x38(%rsp),%r13
mov    0x18(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,8),%rsi
mov    %r15,%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1b47 <analyze+0x9f7>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1ad0 <analyze+0x980>
jmp    1af9 <analyze+0x9a9>
xor    %ebx,%ebx
mov    0x38(%rsp),%r13
mov    0x18(%rsp),%r15
mov    %r15,0x0(%r13,%rbx,8)
add    $0x1,%r14d
mov    %r14,0x8(%rsp)
xor    %r14d,%r14d
mov    0x10(%rsp),%rbx
jmp    11c4 <analyze+0x74>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4d6(%rip),%rdi
jmp    1b33 <analyze+0x9e3>
lea    0x54c(%rip),%rdi
mov    %r12,%rsi
jmp    1b51 <analyze+0xa01>
lea    0x4ff(%rip),%rdi
mov    %r14,%rsi
mov    %r15,%rdx
jmp    1b71 <analyze+0xa21>
lea    0x56f(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
lea    0x4d5(%rip),%rdi
mov    %r15,%rsi
mov    0x18(%rsp),%rdx
xor    %eax,%eax
call   1060 <error@plt>
mov    $0x1,%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@.str = [62 x i8] c"error: missing argument delimiter '(' in automaton head '%s'\0A\00"
@.str.1 = [65 x i8] c"error: multiple declaration of parameter '%s' in automaton '%s'\0A\00"
@.str.2 = [62 x i8] c"error: missing argument delimiter ')' in automaton head '%s'\0A\00"
@.str.3 = [47 x i8] c"error: multiple declaration of automaton '%s'\0A\00"
@.str.4 = [87 x i8] c"error: multiple assignment to variable '%s' within the same ruleset in automaton '%s'\0A\00"
define void @analyze(i8** %0, i32 %1) {
%3 = alloca i8**
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i8**
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
store i8** %0, i8*** %3
store i32 %1, i32* %4
%20 = load i32, i32* %4
%21 = zext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = trunc i64 %22 to i32
%24 = call i8* @malloc(i32 %23)
%25 = bitcast i8* %24 to i8**
store i8** %25, i8*** %5
%26 = load i32, i32* %4
%27 = zext i32 %26 to i64
%28 = mul i64 %27, 4
%29 = trunc i64 %28 to i32
%30 = call i8* @malloc(i32 %29)
%31 = bitcast i8* %30 to i32*
store i32* %31, i32** %6
store i32 0, i32* %7
%32 = load i32, i32* %4
%33 = zext i32 %32 to i64
%34 = mul i64 %33, 8
%35 = trunc i64 %34 to i32
%36 = call i8* @malloc(i32 %35)
%37 = bitcast i8* %36 to i8**
store i8** %37, i8*** %8
store i32 0, i32* %9
store i32 0, i32* %10
br label %38
38: ; preds = %525, %2
%39 = load i32, i32* %10
%40 = load i32, i32* %4
%41 = icmp ult i32 %39, %40
br i1 %41, label %42, label %528
42: ; preds = %38
%43 = load i8**, i8*** %3
%44 = load i32, i32* %10
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds i8*, i8** %43, i64 %45
%47 = load i8*, i8** %46
%48 = getelementptr inbounds i8, i8* %47, i64 0
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = icmp eq i32 %50, 64
br i1 %51, label %52, label %379
52: ; preds = %42
store i32 0, i32* %11
br label %53
53: ; preds = %80, %52
%54 = load i8**, i8*** %3
%55 = load i32, i32* %10
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i8*, i8** %54, i64 %56
%58 = load i8*, i8** %57
%59 = load i32, i32* %11
%60 = zext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = icmp ne i32 %63, 40
br i1 %64, label %65, label %77
65: ; preds = %53
%66 = load i8**, i8*** %3
%67 = load i32, i32* %10
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i8*, i8** %66, i64 %68
%70 = load i8*, i8** %69
%71 = load i32, i32* %11
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = icmp ne i32 %75, 0
br label %77
77: ; preds = %65, %53
%78 = phi i1 [ false, %53 ], [ %76, %65 ]
br i1 %78, label %79, label %83
79: ; preds = %77
br label %80
80: ; preds = %79
%81 = load i32, i32* %11
%82 = add i32 %81, 1
store i32 %82, i32* %11
br label %53
83: ; preds = %77
%84 = load i8**, i8*** %3
%85 = load i32, i32* %10
%86 = zext i32 %85 to i64
%87 = getelementptr inbounds i8*, i8** %84, i64 %86
%88 = load i8*, i8** %87
%89 = load i32, i32* %11
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = icmp eq i32 %93, 0
br i1 %94, label %95, label %103
95: ; preds = %83
%96 = load i8**, i8*** %3
%97 = load i32, i32* %10
%98 = zext i32 %97 to i64
%99 = getelementptr inbounds i8*, i8** %96, i64 %98
%100 = load i8*, i8** %99
%101 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i64 0, i64 0), i8* %100)
%102 = call i32 @exit(i32 1)
unreachable
103: ; preds = %83
%104 = load i32, i32* %11
%105 = add i32 %104, 1
%106 = zext i32 %105 to i64
%107 = mul i64 %106, 1
%108 = trunc i64 %107 to i32
%109 = call i8* @malloc(i32 %108)
store i8* %109, i8** %13
store i32 0, i32* %12
br label %110
110: ; preds = %128, %103
%111 = load i32, i32* %12
%112 = load i32, i32* %11
%113 = icmp ult i32 %111, %112
br i1 %113, label %114, label %131
114: ; preds = %110
%115 = load i8**, i8*** %3
%116 = load i32, i32* %10
%117 = zext i32 %116 to i64
%118 = getelementptr inbounds i8*, i8** %115, i64 %117
%119 = load i8*, i8** %118
%120 = load i32, i32* %12
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8, i8* %122
%124 = load i8*, i8** %13
%125 = load i32, i32* %12
%126 = zext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %124, i64 %126
store i8 %123, i8* %127
br label %128
128: ; preds = %114
%129 = load i32, i32* %12
%130 = add i32 %129, 1
store i32 %130, i32* %12
br label %110
131: ; preds = %110
%132 = load i8*, i8** %13
%133 = load i32, i32* %11
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %132, i64 %134
store i8 0, i8* %135
%136 = call i8* @malloc(i32 1024)
%137 = bitcast i8* %136 to i8**
store i8** %137, i8*** %14
store i32 0, i32* %15
%138 = load i32, i32* %11
%139 = add i32 %138, 1
store i32 %139, i32* %16
%140 = load i32, i32* %16
store i32 %140, i32* %11
br label %141
141: ; preds = %259, %131
%142 = load i8**, i8*** %3
%143 = load i32, i32* %10
%144 = zext i32 %143 to i64
%145 = getelementptr inbounds i8*, i8** %142, i64 %144
%146 = load i8*, i8** %145
%147 = load i32, i32* %11
%148 = zext i32 %147 to i64
%149 = getelementptr inbounds i8, i8* %146, i64 %148
%150 = load i8, i8* %149
%151 = sext i8 %150 to i32
%152 = icmp ne i32 %151, 41
br i1 %152, label %153, label %262
153: ; preds = %141
%154 = load i8**, i8*** %3
%155 = load i32, i32* %10
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds i8*, i8** %154, i64 %156
%158 = load i8*, i8** %157
%159 = load i32, i32* %11
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %158, i64 %160
%162 = load i8, i8* %161
%163 = sext i8 %162 to i32
%164 = icmp eq i32 %163, 44
br i1 %164, label %165, label %237
165: ; preds = %153
%166 = load i32, i32* %11
%167 = load i32, i32* %16
%168 = sub i32 %166, %167
%169 = add i32 %168, 1
%170 = zext i32 %169 to i64
%171 = mul i64 %170, 1
%172 = trunc i64 %171 to i32
%173 = call i8* @malloc(i32 %172)
store i8* %173, i8** %17
%174 = load i32, i32* %16
store i32 %174, i32* %12
br label %175
175: ; preds = %195, %165
%176 = load i32, i32* %12
%177 = load i32, i32* %11
%178 = icmp ult i32 %176, %177
br i1 %178, label %179, label %198
179: ; preds = %175
%180 = load i8**, i8*** %3
%181 = load i32, i32* %10
%182 = zext i32 %181 to i64
%183 = getelementptr inbounds i8*, i8** %180, i64 %182
%184 = load i8*, i8** %183
%185 = load i32, i32* %12
%186 = zext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %184, i64 %186
%188 = load i8, i8* %187
%189 = load i8*, i8** %17
%190 = load i32, i32* %12
%191 = load i32, i32* %16
%192 = sub i32 %190, %191
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %189, i64 %193
store i8 %188, i8* %194
br label %195
195: ; preds = %179
%196 = load i32, i32* %12
%197 = add i32 %196, 1
store i32 %197, i32* %12
br label %175
198: ; preds = %175
%199 = load i8*, i8** %17
%200 = load i32, i32* %12
%201 = load i32, i32* %16
%202 = sub i32 %200, %201
%203 = zext i32 %202 to i64
%204 = getelementptr inbounds i8, i8* %199, i64 %203
store i8 0, i8* %204
store i32 0, i32* %12
br label %205
205: ; preds = %224, %198
%206 = load i32, i32* %12
%207 = load i32, i32* %15
%208 = icmp ult i32 %206, %207
br i1 %208, label %209, label %227
209: ; preds = %205
%210 = load i8*, i8** %17
%211 = load i8**, i8*** %14
%212 = load i32, i32* %12
%213 = zext i32 %212 to i64
%214 = getelementptr inbounds i8*, i8** %211, i64 %213
%215 = load i8*, i8** %214
%216 = call i64 @strcmp(i8* %210, i8* %215)
%217 = icmp eq i64 %216, 0
br i1 %217, label %218, label %223
218: ; preds = %209
%219 = load i8*, i8** %17
%220 = load i8*, i8** %13
%221 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.1, i64 0, i64 0), i8* %219, i8* %220)
%222 = call i32 @exit(i32 1)
unreachable
223: ; preds = %209
br label %224
224: ; preds = %223
%225 = load i32, i32* %12
%226 = add i32 %225, 1
store i32 %226, i32* %12
br label %205
227: ; preds = %205
%228 = load i8*, i8** %17
%229 = load i8**, i8*** %14
%230 = load i32, i32* %15
%231 = zext i32 %230 to i64
%232 = getelementptr inbounds i8*, i8** %229, i64 %231
store i8* %228, i8** %232
%233 = load i32, i32* %15
%234 = add i32 %233, 1
store i32 %234, i32* %15
%235 = load i32, i32* %11
%236 = add i32 %235, 1
store i32 %236, i32* %16
br label %258
237: ; preds = %153
%238 = load i8**, i8*** %3
%239 = load i32, i32* %10
%240 = zext i32 %239 to i64
%241 = getelementptr inbounds i8*, i8** %238, i64 %240
%242 = load i8*, i8** %241
%243 = load i32, i32* %11
%244 = zext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
%246 = load i8, i8* %245
%247 = sext i8 %246 to i32
%248 = icmp eq i32 %247, 0
br i1 %248, label %249, label %257
249: ; preds = %237
%250 = load i8**, i8*** %3
%251 = load i32, i32* %10
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds i8*, i8** %250, i64 %252
%254 = load i8*, i8** %253
%255 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.2, i64 0, i64 0), i8* %254)
%256 = call i32 @exit(i32 1)
unreachable
257: ; preds = %237
br label %258
258: ; preds = %257, %227
br label %259
259: ; preds = %258
%260 = load i32, i32* %11
%261 = add i32 %260, 1
store i32 %261, i32* %11
br label %141
262: ; preds = %141
%263 = load i8**, i8*** %3
%264 = load i32, i32* %10
%265 = zext i32 %264 to i64
%266 = getelementptr inbounds i8*, i8** %263, i64 %265
%267 = load i8*, i8** %266
%268 = load i32, i32* %16
%269 = zext i32 %268 to i64
%270 = getelementptr inbounds i8, i8* %267, i64 %269
%271 = load i8, i8* %270
%272 = sext i8 %271 to i32
%273 = icmp ne i32 %272, 41
br i1 %273, label %274, label %344
274: ; preds = %262
%275 = load i32, i32* %11
%276 = load i32, i32* %16
%277 = sub i32 %275, %276
%278 = add i32 %277, 1
%279 = zext i32 %278 to i64
%280 = mul i64 %279, 1
%281 = trunc i64 %280 to i32
%282 = call i8* @malloc(i32 %281)
store i8* %282, i8** %18
%283 = load i32, i32* %16
store i32 %283, i32* %12
br label %284
284: ; preds = %304, %274
%285 = load i32, i32* %12
%286 = load i32, i32* %11
%287 = icmp ult i32 %285, %286
br i1 %287, label %288, label %307
288: ; preds = %284
%289 = load i8**, i8*** %3
%290 = load i32, i32* %10
%291 = zext i32 %290 to i64
%292 = getelementptr inbounds i8*, i8** %289, i64 %291
%293 = load i8*, i8** %292
%294 = load i32, i32* %12
%295 = zext i32 %294 to i64
%296 = getelementptr inbounds i8, i8* %293, i64 %295
%297 = load i8, i8* %296
%298 = load i8*, i8** %18
%299 = load i32, i32* %12
%300 = load i32, i32* %16
%301 = sub i32 %299, %300
%302 = zext i32 %301 to i64
%303 = getelementptr inbounds i8, i8* %298, i64 %302
store i8 %297, i8* %303
br label %304
304: ; preds = %288
%305 = load i32, i32* %12
%306 = add i32 %305, 1
store i32 %306, i32* %12
br label %284
307: ; preds = %284
%308 = load i8*, i8** %18
%309 = load i32, i32* %12
%310 = load i32, i32* %16
%311 = sub i32 %309, %310
%312 = zext i32 %311 to i64
%313 = getelementptr inbounds i8, i8* %308, i64 %312
store i8 0, i8* %313
store i32 0, i32* %12
br label %314
314: ; preds = %333, %307
%315 = load i32, i32* %12
%316 = load i32, i32* %15
%317 = icmp ult i32 %315, %316
br i1 %317, label %318, label %336
318: ; preds = %314
%319 = load i8*, i8** %18
%320 = load i8**, i8*** %14
%321 = load i32, i32* %12
%322 = zext i32 %321 to i64
%323 = getelementptr inbounds i8*, i8** %320, i64 %322
%324 = load i8*, i8** %323
%325 = call i64 @strcmp(i8* %319, i8* %324)
%326 = icmp eq i64 %325, 0
br i1 %326, label %327, label %332
327: ; preds = %318
%328 = load i8*, i8** %18
%329 = load i8*, i8** %13
%330 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.1, i64 0, i64 0), i8* %328, i8* %329)
%331 = call i32 @exit(i32 1)
unreachable
332: ; preds = %318
br label %333
333: ; preds = %332
%334 = load i32, i32* %12
%335 = add i32 %334, 1
store i32 %335, i32* %12
br label %314
336: ; preds = %314
%337 = load i8*, i8** %18
%338 = load i8**, i8*** %14
%339 = load i32, i32* %15
%340 = zext i32 %339 to i64
%341 = getelementptr inbounds i8*, i8** %338, i64 %340
store i8* %337, i8** %341
%342 = load i32, i32* %15
%343 = add i32 %342, 1
store i32 %343, i32* %15
br label %344
344: ; preds = %336, %262
store i32 0, i32* %11
br label %345
345: ; preds = %363, %344
%346 = load i32, i32* %11
%347 = load i32, i32* %7
%348 = icmp ult i32 %346, %347
br i1 %348, label %349, label %366
349: ; preds = %345
%350 = load i8*, i8** %13
%351 = load i8**, i8*** %5
%352 = load i32, i32* %11
%353 = zext i32 %352 to i64
%354 = getelementptr inbounds i8*, i8** %351, i64 %353
%355 = load i8*, i8** %354
%356 = call i64 @strcmp(i8* %350, i8* %355)
%357 = icmp eq i64 %356, 0
br i1 %357, label %358, label %362
358: ; preds = %349
%359 = load i8*, i8** %13
%360 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.3, i64 0, i64 0), i8* %359)
%361 = call i32 @exit(i32 1)
unreachable
362: ; preds = %349
br label %363
363: ; preds = %362
%364 = load i32, i32* %11
%365 = add i32 %364, 1
store i32 %365, i32* %11
br label %345
366: ; preds = %345
%367 = load i8*, i8** %13
%368 = load i8**, i8*** %5
%369 = load i32, i32* %7
%370 = zext i32 %369 to i64
%371 = getelementptr inbounds i8*, i8** %368, i64 %370
store i8* %367, i8** %371
%372 = load i32, i32* %15
%373 = load i32*, i32** %6
%374 = load i32, i32* %7
%375 = zext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %373, i64 %375
store i32 %372, i32* %376
%377 = load i32, i32* %7
%378 = add i32 %377, 1
store i32 %378, i32* %7
store i32 0, i32* %9
br label %524
379: ; preds = %42
%380 = load i8**, i8*** %3
%381 = load i32, i32* %10
%382 = zext i32 %381 to i64
%383 = getelementptr inbounds i8*, i8** %380, i64 %382
%384 = load i8*, i8** %383
%385 = call i64 @is_separator(i8* %384)
%386 = icmp ne i64 %385, 0
br i1 %386, label %387, label %388
387: ; preds = %379
store i32 0, i32* %9
br label %523
388: ; preds = %379
%389 = load i32, i32* %7
%390 = icmp ugt i32 %389, 0
br i1 %390, label %391, label %522
391: ; preds = %388
store i32 0, i32* %11
br label %392
392: ; preds = %418, %391
%393 = load i8**, i8*** %3
%394 = load i32, i32* %10
%395 = zext i32 %394 to i64
%396 = getelementptr inbounds i8*, i8** %393, i64 %395
%397 = load i8*, i8** %396
%398 = load i32, i32* %11
%399 = zext i32 %398 to i64
%400 = getelementptr inbounds i8, i8* %397, i64 %399
%401 = load i8, i8* %400
%402 = sext i8 %401 to i32
%403 = icmp ne i32 %402, 58
br i1 %403, label %404, label %416
404: ; preds = %392
%405 = load i8**, i8*** %3
%406 = load i32, i32* %10
%407 = zext i32 %406 to i64
%408 = getelementptr inbounds i8*, i8** %405, i64 %407
%409 = load i8*, i8** %408
%410 = load i32, i32* %11
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %409, i64 %411
%413 = load i8, i8* %412
%414 = sext i8 %413 to i32
%415 = icmp ne i32 %414, 0
br label %416
416: ; preds = %404, %392
%417 = phi i1 [ false, %392 ], [ %415, %404 ]
br i1 %417, label %418, label %421
418: ; preds = %416
%419 = load i32, i32* %11
%420 = add i32 %419, 1
store i32 %420, i32* %11
br label %392
421: ; preds = %416
%422 = load i32, i32* %11
%423 = add i32 %422, 1
%424 = zext i32 %423 to i64
%425 = mul i64 %424, 1
%426 = trunc i64 %425 to i32
%427 = call i8* @malloc(i32 %426)
store i8* %427, i8** %19
store i32 0, i32* %11
br label %428
428: ; preds = %454, %421
%429 = load i8**, i8*** %3
%430 = load i32, i32* %10
%431 = zext i32 %430 to i64
%432 = getelementptr inbounds i8*, i8** %429, i64 %431
%433 = load i8*, i8** %432
%434 = load i32, i32* %11
%435 = zext i32 %434 to i64
%436 = getelementptr inbounds i8, i8* %433, i64 %435
%437 = load i8, i8* %436
%438 = sext i8 %437 to i32
%439 = icmp ne i32 %438, 58
br i1 %439, label %440, label %452
440: ; preds = %428
%441 = load i8**, i8*** %3
%442 = load i32, i32* %10
%443 = zext i32 %442 to i64
%444 = getelementptr inbounds i8*, i8** %441, i64 %443
%445 = load i8*, i8** %444
%446 = load i32, i32* %11
%447 = zext i32 %446 to i64
%448 = getelementptr inbounds i8, i8* %445, i64 %447
%449 = load i8, i8* %448
%450 = sext i8 %449 to i32
%451 = icmp ne i32 %450, 0
br label %452
452: ; preds = %440, %428
%453 = phi i1 [ false, %428 ], [ %451, %440 ]
br i1 %453, label %454, label %470
454: ; preds = %452
%455 = load i8**, i8*** %3
%456 = load i32, i32* %10
%457 = zext i32 %456 to i64
%458 = getelementptr inbounds i8*, i8** %455, i64 %457
%459 = load i8*, i8** %458
%460 = load i32, i32* %11
%461 = zext i32 %460 to i64
%462 = getelementptr inbounds i8, i8* %459, i64 %461
%463 = load i8, i8* %462
%464 = load i8*, i8** %19
%465 = load i32, i32* %11
%466 = zext i32 %465 to i64
%467 = getelementptr inbounds i8, i8* %464, i64 %466
store i8 %463, i8* %467
%468 = load i32, i32* %11
%469 = add i32 %468, 1
store i32 %469, i32* %11
br label %428
470: ; preds = %452
%471 = load i8*, i8** %19
%472 = load i32, i32* %11
%473 = zext i32 %472 to i64
%474 = getelementptr inbounds i8, i8* %471, i64 %473
store i8 0, i8* %474
%475 = load i8**, i8*** %3
%476 = load i32, i32* %10
%477 = zext i32 %476 to i64
%478 = getelementptr inbounds i8*, i8** %475, i64 %477
%479 = load i8*, i8** %478
%480 = load i32, i32* %11
%481 = zext i32 %480 to i64
%482 = getelementptr inbounds i8, i8* %479, i64 %481
%483 = load i8, i8* %482
%484 = sext i8 %483 to i32
%485 = icmp eq i32 %484, 58
br i1 %485, label %486, label %521
486: ; preds = %470
store i32 0, i32* %11
br label %487
487: ; preds = %510, %486
%488 = load i32, i32* %11
%489 = load i32, i32* %9
%490 = icmp ult i32 %488, %489
br i1 %490, label %491, label %513
491: ; preds = %487
%492 = load i8*, i8** %19
%493 = load i8**, i8*** %8
%494 = load i32, i32* %11
%495 = zext i32 %494 to i64
%496 = getelementptr inbounds i8*, i8** %493, i64 %495
%497 = load i8*, i8** %496
%498 = call i64 @strcmp(i8* %492, i8* %497)
%499 = icmp eq i64 %498, 0
br i1 %499, label %500, label %509
500: ; preds = %491
%501 = load i8*, i8** %19
%502 = load i8**, i8*** %5
%503 = load i32, i32* %7
%504 = sub i32 %503, 1
%505 = zext i32 %504 to i64
%506 = getelementptr inbounds i8*, i8** %502, i64 %505
%507 = load i8*, i8** %506
%508 = call i32 (i8*, i8*, ...) @error(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.4, i64 0, i64 0), i8* %501, i8* %507)
br label %509
509: ; preds = %500, %491
br label %510
510: ; preds = %509
%511 = load i32, i32* %11
%512 = add i32 %511, 1
store i32 %512, i32* %11
br label %487
513: ; preds = %487
%514 = load i8*, i8** %19
%515 = load i8**, i8*** %8
%516 = load i32, i32* %9
%517 = zext i32 %516 to i64
%518 = getelementptr inbounds i8*, i8** %515, i64 %517
store i8* %514, i8** %518
%519 = load i32, i32* %9
%520 = add i32 %519, 1
store i32 %520, i32* %9
br label %521
521: ; preds = %513, %470
br label %522
522: ; preds = %521, %388
br label %523
523: ; preds = %522, %387
br label %524
524: ; preds = %523, %366
br label %525
525: ; preds = %524
%526 = load i32, i32* %10
%527 = add i32 %526, 1
store i32 %527, i32* %10
br label %38
528: ; preds = %38
ret void
}

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