#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 */
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
void edge_type(long nh, char **hb_atm, long i, char *bseq, char *type_wd) {
  long k, max1, max2, max, Watson = 0, Hoogsteen = 0, Suger = 0;
  long s = 0, h = 0, w = 0;
  if (bseq[i] == 'A' || bseq[i] == 'a') {
    for (k = 1; k <= nh; k++) {
      if (strcmp(hb_atm[k], " N1 ") == 0 || strcmp(hb_atm[k], " C2 ") == 0 ||
          strcmp(hb_atm[k], " N6 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " N6 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " N7 ") == 0 || strcmp(hb_atm[k], " C8 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " C2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " C4 ") == 0 || strcmp(hb_atm[k], " N9 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " C3'") == 0 || strcmp(hb_atm[k], " O3'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  } else if (bseq[i] == 'I' || bseq[i] == 'i') {
    for (k = 1; k <= nh; k++) {
      if (k > 1 && !strcmp(hb_atm[k], hb_atm[k - 1]))
        continue;
      if (strcmp(hb_atm[k], " N1 ") == 0 || strcmp(hb_atm[k], " C2 ") == 0 ||
          strcmp(hb_atm[k], " O6 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " O6 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " N7 ") == 0 || strcmp(hb_atm[k], " C8 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " C2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " C4 ") == 0 || strcmp(hb_atm[k], " N9 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " C3'") == 0 || strcmp(hb_atm[k], " O3'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  } else if (bseq[i] == 'G' || bseq[i] == 'g') {
    for (k = 1; k <= nh; k++) {
      if (k > 1 && !strcmp(hb_atm[k], hb_atm[k - 1]))
        continue;
      if (strcmp(hb_atm[k], " N2 ") == 0 || strcmp(hb_atm[k], " N1 ") == 0 ||
          strcmp(hb_atm[k], " O6 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " O6 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " N7 ") == 0 || strcmp(hb_atm[k], " C8 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " N2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " C4 ") == 0 || strcmp(hb_atm[k], " N9 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  } else if (bseq[i] == 'C' || bseq[i] == 'c') {
    for (k = 1; k <= nh; k++) {
      if (k > 1 && !strcmp(hb_atm[k], hb_atm[k - 1]))
        continue;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " N4 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " N4 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " C6 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " N1 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " C3'") == 0 || strcmp(hb_atm[k], " O3'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  } else if (bseq[i] == 'U' || bseq[i] == 'T' || bseq[i] == 'u' ||
             bseq[i] == 't') {
    for (k = 1; k <= nh; k++) {
      if (k > 1 && !strcmp(hb_atm[k], hb_atm[k - 1]))
        continue;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " O4 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " O4 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " C6 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " N1 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " C3'") == 0 || strcmp(hb_atm[k], " O3'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  } else if (bseq[i] == 'P' || bseq[i] == 'p') {
    for (k = 1; k <= nh; k++) {
      if (k > 1 && !strcmp(hb_atm[k], hb_atm[k - 1]))
        continue;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " N3 ") == 0 ||
          strcmp(hb_atm[k], " O4 ") == 0)
        Watson++;
      if (strcmp(hb_atm[k], " O4 ") == 0 || strcmp(hb_atm[k], " N1 ") == 0 ||
          strcmp(hb_atm[k], " C6 ") == 0)
        Hoogsteen++;
      if (strcmp(hb_atm[k], " O2 ") == 0 || strcmp(hb_atm[k], " C5 ") == 0 ||
          strcmp(hb_atm[k], " C1'") == 0 || strcmp(hb_atm[k], " C2'") == 0 ||
          strcmp(hb_atm[k], " C3'") == 0 || strcmp(hb_atm[k], " O3'") == 0 ||
          strcmp(hb_atm[k], " O2'") == 0)
        Suger++;
    };
  }
  w = Watson;
  h = Hoogsteen;
  s = Suger;
  max1 = (Watson >= Hoogsteen) ? Watson : Hoogsteen;
  max2 = (Hoogsteen >= Suger) ? Hoogsteen : Suger;
  max = (max1 >= max2) ? max1 : max2;
  if (Watson == max)
    strcpy(type_wd, "W");
  else if (Hoogsteen == max)
    strcpy(type_wd, "H");
  else if (Suger == max)
    strcpy(type_wd, "S");
  if (max == 0)
    strcpy(type_wd, "?");
  if (max == 1)
    strcpy(type_wd, ".");
}


x86 assembly (clang, -O0):
<edge_type>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
je     1199 <edge_type+0x79>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jne    140e <edge_type+0x2ee>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1409 <edge_type+0x2e9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1e3e(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1215 <edge_type+0xf5>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1e21(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1215 <edge_type+0xf5>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1e04(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1221 <edge_type+0x101>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1dd6(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     12a9 <edge_type+0x189>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1db9(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     12a9 <edge_type+0x189>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1d9c(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     12a9 <edge_type+0x189>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1d7f(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    12b5 <edge_type+0x195>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1d3d(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1d34(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1d17(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cfa(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cdd(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cc0(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1ca3(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c86(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     13e7 <edge_type+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c69(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    13f3 <edge_type+0x2d3>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13f8 <edge_type+0x2d8>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11a1 <edge_type+0x81>
jmp    211d <edge_type+0xffd>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x49,%eax
je     1438 <edge_type+0x318>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x69,%eax
jne    16e8 <edge_type+0x5c8>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     16e3 <edge_type+0x5c3>
cmpq   $0x1,-0x30(%rbp)
jle    1489 <edge_type+0x369>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1489 <edge_type+0x369>
jmp    16d2 <edge_type+0x5b2>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b64(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     14ef <edge_type+0x3cf>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b47(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     14ef <edge_type+0x3cf>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b66(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    14fb <edge_type+0x3db>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b38(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1583 <edge_type+0x463>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1adf(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1583 <edge_type+0x463>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1ac2(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1583 <edge_type+0x463>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1aa5(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    158f <edge_type+0x46f>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a63(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a5a(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a3d(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a20(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a03(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19e6(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19c9(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19ac(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     16c1 <edge_type+0x5a1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x198f(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    16cd <edge_type+0x5ad>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    16d2 <edge_type+0x5b2>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1440 <edge_type+0x320>
jmp    2118 <edge_type+0xff8>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
je     1712 <edge_type+0x5f2>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x67,%eax
jne    197e <edge_type+0x85e>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1979 <edge_type+0x859>
cmpq   $0x1,-0x30(%rbp)
jle    1763 <edge_type+0x643>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1763 <edge_type+0x643>
jmp    1968 <edge_type+0x848>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x18d5(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     17c9 <edge_type+0x6a9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1868(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     17c9 <edge_type+0x6a9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x188c(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    17d5 <edge_type+0x6b5>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x185e(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     185d <edge_type+0x73d>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1805(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     185d <edge_type+0x73d>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x17e8(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     185d <edge_type+0x73d>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x17cb(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1869 <edge_type+0x749>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x17cf(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1780(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1763(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1746(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1729(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x170c(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1957 <edge_type+0x837>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x16f9(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1963 <edge_type+0x843>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1968 <edge_type+0x848>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    171a <edge_type+0x5fa>
jmp    2113 <edge_type+0xff3>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
je     19a8 <edge_type+0x888>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x63,%eax
jne    1bf2 <edge_type+0xad2>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1bed <edge_type+0xacd>
cmpq   $0x1,-0x30(%rbp)
jle    19f9 <edge_type+0x8d9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    19f9 <edge_type+0x8d9>
jmp    1bdc <edge_type+0xabc>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1644(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1a5f <edge_type+0x93f>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x15f0(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1a5f <edge_type+0x93f>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1605(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1a6b <edge_type+0x94b>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x15d7(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1ad1 <edge_type+0x9b1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x156f(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1ad1 <edge_type+0x9b1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1598(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1add <edge_type+0x9bd>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1560(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x14ee(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x14f9(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x14dc(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x14bf(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x14a2(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1bcb <edge_type+0xaab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1485(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1bd7 <edge_type+0xab7>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1bdc <edge_type+0xabc>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    19b0 <edge_type+0x890>
jmp    210e <edge_type+0xfee>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x55,%eax
je     1c46 <edge_type+0xb26>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x54,%eax
je     1c46 <edge_type+0xb26>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x75,%eax
je     1c46 <edge_type+0xb26>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x74,%eax
jne    1e90 <edge_type+0xd70>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     1e8b <edge_type+0xd6b>
cmpq   $0x1,-0x30(%rbp)
jle    1c97 <edge_type+0xb77>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1c97 <edge_type+0xb77>
jmp    1e7a <edge_type+0xd5a>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x13a6(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1cfd <edge_type+0xbdd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1352(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1cfd <edge_type+0xbdd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1371(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1d09 <edge_type+0xbe9>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1343(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1d6f <edge_type+0xc4f>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x12d1(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1d6f <edge_type+0xc4f>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x12fa(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1d7b <edge_type+0xc5b>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x12c2(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1250(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x125b(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x123e(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1221(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1204(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1e69 <edge_type+0xd49>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x11e7(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1e75 <edge_type+0xd55>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1e7a <edge_type+0xd5a>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1c4e <edge_type+0xb2e>
jmp    2109 <edge_type+0xfe9>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x50,%eax
je     1eba <edge_type+0xd9a>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x70,%eax
jne    2104 <edge_type+0xfe4>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x8(%rbp),%rax
jg     20ff <edge_type+0xfdf>
cmpq   $0x1,-0x30(%rbp)
jle    1f0b <edge_type+0xdeb>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1f0b <edge_type+0xdeb>
jmp    20ee <edge_type+0xfce>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1132(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1f71 <edge_type+0xe51>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x10de(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1f71 <edge_type+0xe51>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x10fd(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1f7d <edge_type+0xe5d>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x10cf(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1fe3 <edge_type+0xec3>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x104e(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     1fe3 <edge_type+0xec3>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1086(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    1fef <edge_type+0xecf>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x104e(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xfeb(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xfe7(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xfca(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xfad(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xf90(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
je     20dd <edge_type+0xfbd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xf73(%rip),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
jne    20e9 <edge_type+0xfc9>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    20ee <edge_type+0xfce>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1ec2 <edge_type+0xda2>
jmp    2104 <edge_type+0xfe4>
jmp    2109 <edge_type+0xfe9>
jmp    210e <edge_type+0xfee>
jmp    2113 <edge_type+0xff3>
jmp    2118 <edge_type+0xff8>
jmp    211d <edge_type+0xffd>
mov    -0x50(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
jl     2150 <edge_type+0x1030>
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
jmp    2158 <edge_type+0x1038>
mov    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jl     217e <edge_type+0x105e>
mov    -0x58(%rbp),%rax
mov    %rax,-0x88(%rbp)
jmp    2189 <edge_type+0x1069>
mov    -0x60(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jl     21b2 <edge_type+0x1092>
mov    -0x38(%rbp),%rax
mov    %rax,-0x90(%rbp)
jmp    21bd <edge_type+0x109d>
mov    -0x40(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    21eb <edge_type+0x10cb>
mov    -0x28(%rbp),%rdi
lea    0xe83(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2236 <edge_type+0x1116>
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    220e <edge_type+0x10ee>
mov    -0x28(%rbp),%rdi
lea    0xe62(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2231 <edge_type+0x1111>
mov    -0x60(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    222c <edge_type+0x110c>
mov    -0x28(%rbp),%rdi
lea    0xe41(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2231 <edge_type+0x1111>
jmp    2236 <edge_type+0x1116>
cmpq   $0x0,-0x48(%rbp)
jne    2251 <edge_type+0x1131>
mov    -0x28(%rbp),%rdi
lea    0xe1e(%rip),%rsi
call   1030 <strcpy@plt>
cmpq   $0x1,-0x48(%rbp)
jne    226c <edge_type+0x114c>
mov    -0x28(%rbp),%rdi
lea    0xe05(%rip),%rsi
call   1030 <strcpy@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<edge_type>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8,(%rsp)
mov    (%rcx,%rdx,1),%al
xor    %r12d,%r12d
add    $0xbf,%al
cmp    $0x34,%al
ja     1bdb <edge_type+0xabb>
mov    %rsi,%rbx
movzbl %al,%eax
lea    0xeb4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
xor    %r14d,%r14d
xor    %r13d,%r13d
jmp    *%rax
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
neg    %rdi
mov    $0x1,%r15d
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    119d <edge_type+0x7d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    %rbp,%rdi
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%r15
cmp    $0x1,%rax
je     1be1 <edge_type+0xac1>
mov    %rdi,%rbp
cmp    $0x2,%r15
jb     11b9 <edge_type+0x99>
mov    -0x8(%rbx,%r15,8),%rsi
mov    (%rbx,%r15,8),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1184 <edge_type+0x64>
mov    (%rbx,%r15,8),%rdi
lea    0xf60(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1200 <edge_type+0xe0>
mov    (%rbx,%r15,8),%rdi
lea    0xf19(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1200 <edge_type+0xe0>
mov    (%rbx,%r15,8),%rdi
lea    0xf45(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1204 <edge_type+0xe4>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    (%rbx,%r15,8),%rdi
lea    0xf24(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1250 <edge_type+0x130>
mov    (%rbx,%r15,8),%rdi
lea    0xebf(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1250 <edge_type+0x130>
mov    (%rbx,%r15,8),%rdi
lea    0xef5(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1254 <edge_type+0x134>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
mov    (%rbx,%r15,8),%rdi
lea    0xec5(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe5c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe70(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe5c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe48(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe34(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1180 <edge_type+0x60>
mov    (%rbx,%r15,8),%rdi
lea    0xe20(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1184 <edge_type+0x64>
jmp    1180 <edge_type+0x60>
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
xor    %ebp,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
nopl   0x0(%rax)
mov    %rdi,%r15
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xda5(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1370 <edge_type+0x250>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd94(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1370 <edge_type+0x250>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd83(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1374 <edge_type+0x254>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd5e(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     13d0 <edge_type+0x2b0>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd4d(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     13d0 <edge_type+0x2b0>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd3c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     13d0 <edge_type+0x2b0>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xd2b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    13d4 <edge_type+0x2b4>
nopl   0x0(%rax)
add    $0x1,%r14
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xcf9(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xcf8(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xce3(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xcce(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xcbd(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xcac(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xc9b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xc8a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14b0 <edge_type+0x390>
mov    0x8(%rbx,%rbp,8),%rdi
lea    0xc79(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    14b4 <edge_type+0x394>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
mov    %r15,%rdi
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1320 <edge_type+0x200>
jmp    1be1 <edge_type+0xac1>
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
neg    %rdi
mov    $0x1,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    150d <edge_type+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
mov    %r15,%rdi
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    $0x1,%rax
je     1be1 <edge_type+0xac1>
mov    %rdi,%r15
cmp    $0x2,%rbp
jb     1529 <edge_type+0x409>
mov    -0x8(%rbx,%rbp,8),%rsi
mov    (%rbx,%rbp,8),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f4 <edge_type+0x3d4>
mov    (%rbx,%rbp,8),%rdi
lea    0xbf0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1570 <edge_type+0x450>
mov    (%rbx,%rbp,8),%rdi
lea    0xba9(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1570 <edge_type+0x450>
mov    (%rbx,%rbp,8),%rdi
lea    0xbcb(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1574 <edge_type+0x454>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    (%rbx,%rbp,8),%rdi
lea    0xbaa(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     15c0 <edge_type+0x4a0>
mov    (%rbx,%rbp,8),%rdi
lea    0xb4f(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     15c0 <edge_type+0x4a0>
mov    (%rbx,%rbp,8),%rdi
lea    0xb85(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    15c4 <edge_type+0x4a4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
mov    (%rbx,%rbp,8),%rdi
lea    0xb55(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xaec(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xb00(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xaec(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xad8(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xac4(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     14f0 <edge_type+0x3d0>
mov    (%rbx,%rbp,8),%rdi
lea    0xab0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    14f4 <edge_type+0x3d4>
jmp    14f0 <edge_type+0x3d0>
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
neg    %rdi
mov    $0x1,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    16bd <edge_type+0x59d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
mov    %r15,%rdi
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    $0x1,%rax
je     1be1 <edge_type+0xac1>
mov    %rdi,%r15
cmp    $0x2,%rbp
jb     16d9 <edge_type+0x5b9>
mov    -0x8(%rbx,%rbp,8),%rsi
mov    (%rbx,%rbp,8),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a4 <edge_type+0x584>
mov    (%rbx,%rbp,8),%rdi
lea    0xa3b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1720 <edge_type+0x600>
mov    (%rbx,%rbp,8),%rdi
lea    0x9db(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1720 <edge_type+0x600>
mov    (%rbx,%rbp,8),%rdi
lea    0xa0c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1724 <edge_type+0x604>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    (%rbx,%rbp,8),%rdi
lea    0x9eb(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1780 <edge_type+0x660>
mov    (%rbx,%rbp,8),%rdi
lea    0x99f(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1780 <edge_type+0x660>
mov    (%rbx,%rbp,8),%rdi
lea    0x98f(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1780 <edge_type+0x660>
mov    (%rbx,%rbp,8),%rdi
lea    0x97f(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1784 <edge_type+0x664>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    (%rbx,%rbp,8),%rdi
lea    0x990(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x94a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x936(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x922(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x90e(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x8fa(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     16a0 <edge_type+0x580>
mov    (%rbx,%rbp,8),%rdi
lea    0x8f0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    16a4 <edge_type+0x584>
jmp    16a0 <edge_type+0x580>
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
neg    %rdi
mov    $0x1,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    187d <edge_type+0x75d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
mov    %r15,%rdi
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    $0x1,%rax
je     1be1 <edge_type+0xac1>
mov    %rdi,%r15
cmp    $0x2,%rbp
jb     1899 <edge_type+0x779>
mov    -0x8(%rbx,%rbp,8),%rsi
mov    (%rbx,%rbp,8),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1864 <edge_type+0x744>
mov    (%rbx,%rbp,8),%rdi
lea    0x830(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     18e0 <edge_type+0x7c0>
mov    (%rbx,%rbp,8),%rdi
lea    0x820(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     18e0 <edge_type+0x7c0>
mov    (%rbx,%rbp,8),%rdi
lea    0x84c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    18e4 <edge_type+0x7c4>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    (%rbx,%rbp,8),%rdi
lea    0x82b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1940 <edge_type+0x820>
mov    (%rbx,%rbp,8),%rdi
lea    0x7df(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1940 <edge_type+0x820>
mov    (%rbx,%rbp,8),%rdi
lea    0x7cf(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1940 <edge_type+0x820>
mov    (%rbx,%rbp,8),%rdi
lea    0x7bf(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1944 <edge_type+0x824>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    (%rbx,%rbp,8),%rdi
lea    0x78a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x78a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x776(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x762(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x74e(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x73a(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x726(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x712(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1860 <edge_type+0x740>
mov    (%rbx,%rbp,8),%rdi
lea    0x6fe(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1864 <edge_type+0x744>
jmp    1860 <edge_type+0x740>
test   %rdi,%rdi
jle    1bd8 <edge_type+0xab8>
neg    %rdi
mov    $0x1,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    1a6d <edge_type+0x94d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
mov    %r15,%rdi
lea    (%r15,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    $0x1,%rax
je     1be1 <edge_type+0xac1>
mov    %rdi,%r15
cmp    $0x2,%rbp
jb     1a89 <edge_type+0x969>
mov    -0x8(%rbx,%rbp,8),%rsi
mov    (%rbx,%rbp,8),%rdi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a54 <edge_type+0x934>
mov    (%rbx,%rbp,8),%rdi
lea    0x690(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1ad0 <edge_type+0x9b0>
mov    (%rbx,%rbp,8),%rdi
lea    0x649(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1ad0 <edge_type+0x9b0>
mov    (%rbx,%rbp,8),%rdi
lea    0x675(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1ad4 <edge_type+0x9b4>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    (%rbx,%rbp,8),%rdi
lea    0x654(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1b20 <edge_type+0xa00>
mov    (%rbx,%rbp,8),%rdi
lea    0x5e0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1b20 <edge_type+0xa00>
mov    (%rbx,%rbp,8),%rdi
lea    0x625(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1b24 <edge_type+0xa04>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
mov    (%rbx,%rbp,8),%rdi
lea    0x5f5(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x59b(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x5a0(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x58c(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x578(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x564(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
je     1a50 <edge_type+0x930>
mov    (%rbx,%rbp,8),%rdi
lea    0x550(%rip),%rsi
call   1040 <strcmp@plt>
test   %rax,%rax
jne    1a54 <edge_type+0x934>
jmp    1a50 <edge_type+0x930>
xor    %r12d,%r12d
xor    %r14d,%r14d
xor    %r13d,%r13d
cmp    %r14,%r12
mov    %r12,%rax
cmovl  %r14,%rax
cmp    %r13,%rax
mov    %r13,%rbx
cmovg  %rax,%rbx
cmp    %rbx,%r12
jne    1c03 <edge_type+0xae3>
lea    0x537(%rip),%rsi
jmp    1c37 <edge_type+0xb17>
lea    0x530(%rip),%rcx
lea    0x52b(%rip),%rsi
cmp    %rbx,%r14
cmove  %rcx,%rsi
je     1c37 <edge_type+0xb17>
cmp    %r13,%rax
mov    (%rsp),%rbp
jle    1c3b <edge_type+0xb1b>
test   %rbx,%rbx
je     1c48 <edge_type+0xb28>
cmp    $0x1,%rbx
jne    1c65 <edge_type+0xb45>
lea    0x50b(%rip),%rsi
jmp    1c4f <edge_type+0xb2f>
mov    (%rsp),%rbp
mov    %rbp,%rdi
call   1030 <strcpy@plt>
test   %rbx,%rbx
jne    1c28 <edge_type+0xb08>
lea    0x4ef(%rip),%rsi
mov    %rbp,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <strcpy@plt>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c" N1 \00"
@.str.1 = [5 x i8] c" C2 \00"
@.str.2 = [5 x i8] c" N6 \00"
@.str.3 = [5 x i8] c" C5 \00"
@.str.4 = [5 x i8] c" N7 \00"
@.str.5 = [5 x i8] c" C8 \00"
@.str.6 = [5 x i8] c" N3 \00"
@.str.7 = [5 x i8] c" C4 \00"
@.str.8 = [5 x i8] c" N9 \00"
@.str.9 = [5 x i8] c" C1'\00"
@.str.10 = [5 x i8] c" C2'\00"
@.str.11 = [5 x i8] c" C3'\00"
@.str.12 = [5 x i8] c" O3'\00"
@.str.13 = [5 x i8] c" O2'\00"
@.str.14 = [5 x i8] c" O6 \00"
@.str.15 = [5 x i8] c" N2 \00"
@.str.16 = [5 x i8] c" O2 \00"
@.str.17 = [5 x i8] c" N4 \00"
@.str.18 = [5 x i8] c" C6 \00"
@.str.19 = [5 x i8] c" O4 \00"
@.str.20 = [2 x i8] c"W\00"
@.str.21 = [2 x i8] c"H\00"
@.str.22 = [2 x i8] c"S\00"
@.str.23 = [2 x i8] c"?\00"
@.str.24 = [2 x i8] c".\00"
define void @edge_type(i64 %0, i8** %1, i64 %2, i8* %3, i8* %4) {
%6 = alloca i64
%7 = alloca i8**
%8 = alloca i64
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
store i64 %0, i64* %6
store i8** %1, i8*** %7
store i64 %2, i64* %8
store i8* %3, i8** %9
store i8* %4, i8** %10
store i64 0, i64* %15
store i64 0, i64* %16
store i64 0, i64* %17
store i64 0, i64* %18
store i64 0, i64* %19
store i64 0, i64* %20
%21 = load i8*, i8** %9
%22 = load i64, i64* %8
%23 = getelementptr inbounds i8, i8* %21, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp eq i32 %25, 65
br i1 %26, label %34, label %27
27: ; preds = %5
%28 = load i8*, i8** %9
%29 = load i64, i64* %8
%30 = getelementptr inbounds i8, i8* %28, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp eq i32 %32, 97
br i1 %33, label %34, label %165
34: ; preds = %27, %5
store i64 1, i64* %11
br label %35
35: ; preds = %161, %34
%36 = load i64, i64* %11
%37 = load i64, i64* %6
%38 = icmp sle i64 %36, %37
br i1 %38, label %39, label %164
39: ; preds = %35
%40 = load i8**, i8*** %7
%41 = load i64, i64* %11
%42 = getelementptr inbounds i8*, i8** %40, i64 %41
%43 = load i8*, i8** %42
%44 = call i64 @strcmp(i8* %43, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%45 = icmp eq i64 %44, 0
br i1 %45, label %60, label %46
46: ; preds = %39
%47 = load i8**, i8*** %7
%48 = load i64, i64* %11
%49 = getelementptr inbounds i8*, i8** %47, i64 %48
%50 = load i8*, i8** %49
%51 = call i64 @strcmp(i8* %50, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%52 = icmp eq i64 %51, 0
br i1 %52, label %60, label %53
53: ; preds = %46
%54 = load i8**, i8*** %7
%55 = load i64, i64* %11
%56 = getelementptr inbounds i8*, i8** %54, i64 %55
%57 = load i8*, i8** %56
%58 = call i64 @strcmp(i8* %57, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%59 = icmp eq i64 %58, 0
br i1 %59, label %60, label %63
60: ; preds = %53, %46, %39
%61 = load i64, i64* %15
%62 = add nsw i64 %61, 1
store i64 %62, i64* %15
br label %63
63: ; preds = %60, %53
%64 = load i8**, i8*** %7
%65 = load i64, i64* %11
%66 = getelementptr inbounds i8*, i8** %64, i64 %65
%67 = load i8*, i8** %66
%68 = call i64 @strcmp(i8* %67, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%69 = icmp eq i64 %68, 0
br i1 %69, label %91, label %70
70: ; preds = %63
%71 = load i8**, i8*** %7
%72 = load i64, i64* %11
%73 = getelementptr inbounds i8*, i8** %71, i64 %72
%74 = load i8*, i8** %73
%75 = call i64 @strcmp(i8* %74, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%76 = icmp eq i64 %75, 0
br i1 %76, label %91, label %77
77: ; preds = %70
%78 = load i8**, i8*** %7
%79 = load i64, i64* %11
%80 = getelementptr inbounds i8*, i8** %78, i64 %79
%81 = load i8*, i8** %80
%82 = call i64 @strcmp(i8* %81, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%83 = icmp eq i64 %82, 0
br i1 %83, label %91, label %84
84: ; preds = %77
%85 = load i8**, i8*** %7
%86 = load i64, i64* %11
%87 = getelementptr inbounds i8*, i8** %85, i64 %86
%88 = load i8*, i8** %87
%89 = call i64 @strcmp(i8* %88, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%90 = icmp eq i64 %89, 0
br i1 %90, label %91, label %94
91: ; preds = %84, %77, %70, %63
%92 = load i64, i64* %16
%93 = add nsw i64 %92, 1
store i64 %93, i64* %16
br label %94
94: ; preds = %91, %84
%95 = load i8**, i8*** %7
%96 = load i64, i64* %11
%97 = getelementptr inbounds i8*, i8** %95, i64 %96
%98 = load i8*, i8** %97
%99 = call i64 @strcmp(i8* %98, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%100 = icmp eq i64 %99, 0
br i1 %100, label %157, label %101
101: ; preds = %94
%102 = load i8**, i8*** %7
%103 = load i64, i64* %11
%104 = getelementptr inbounds i8*, i8** %102, i64 %103
%105 = load i8*, i8** %104
%106 = call i64 @strcmp(i8* %105, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%107 = icmp eq i64 %106, 0
br i1 %107, label %157, label %108
108: ; preds = %101
%109 = load i8**, i8*** %7
%110 = load i64, i64* %11
%111 = getelementptr inbounds i8*, i8** %109, i64 %110
%112 = load i8*, i8** %111
%113 = call i64 @strcmp(i8* %112, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%114 = icmp eq i64 %113, 0
br i1 %114, label %157, label %115
115: ; preds = %108
%116 = load i8**, i8*** %7
%117 = load i64, i64* %11
%118 = getelementptr inbounds i8*, i8** %116, i64 %117
%119 = load i8*, i8** %118
%120 = call i64 @strcmp(i8* %119, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%121 = icmp eq i64 %120, 0
br i1 %121, label %157, label %122
122: ; preds = %115
%123 = load i8**, i8*** %7
%124 = load i64, i64* %11
%125 = getelementptr inbounds i8*, i8** %123, i64 %124
%126 = load i8*, i8** %125
%127 = call i64 @strcmp(i8* %126, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%128 = icmp eq i64 %127, 0
br i1 %128, label %157, label %129
129: ; preds = %122
%130 = load i8**, i8*** %7
%131 = load i64, i64* %11
%132 = getelementptr inbounds i8*, i8** %130, i64 %131
%133 = load i8*, i8** %132
%134 = call i64 @strcmp(i8* %133, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%135 = icmp eq i64 %134, 0
br i1 %135, label %157, label %136
136: ; preds = %129
%137 = load i8**, i8*** %7
%138 = load i64, i64* %11
%139 = getelementptr inbounds i8*, i8** %137, i64 %138
%140 = load i8*, i8** %139
%141 = call i64 @strcmp(i8* %140, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%142 = icmp eq i64 %141, 0
br i1 %142, label %157, label %143
143: ; preds = %136
%144 = load i8**, i8*** %7
%145 = load i64, i64* %11
%146 = getelementptr inbounds i8*, i8** %144, i64 %145
%147 = load i8*, i8** %146
%148 = call i64 @strcmp(i8* %147, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
%149 = icmp eq i64 %148, 0
br i1 %149, label %157, label %150
150: ; preds = %143
%151 = load i8**, i8*** %7
%152 = load i64, i64* %11
%153 = getelementptr inbounds i8*, i8** %151, i64 %152
%154 = load i8*, i8** %153
%155 = call i64 @strcmp(i8* %154, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%156 = icmp eq i64 %155, 0
br i1 %156, label %157, label %160
157: ; preds = %150, %143, %136, %129, %122, %115, %108, %101, %94
%158 = load i64, i64* %17
%159 = add nsw i64 %158, 1
store i64 %159, i64* %17
br label %160
160: ; preds = %157, %150
br label %161
161: ; preds = %160
%162 = load i64, i64* %11
%163 = add nsw i64 %162, 1
store i64 %163, i64* %11
br label %35
164: ; preds = %35
br label %912
165: ; preds = %27
%166 = load i8*, i8** %9
%167 = load i64, i64* %8
%168 = getelementptr inbounds i8, i8* %166, i64 %167
%169 = load i8, i8* %168
%170 = sext i8 %169 to i32
%171 = icmp eq i32 %170, 73
br i1 %171, label %179, label %172
172: ; preds = %165
%173 = load i8*, i8** %9
%174 = load i64, i64* %8
%175 = getelementptr inbounds i8, i8* %173, i64 %174
%176 = load i8, i8* %175
%177 = sext i8 %176 to i32
%178 = icmp eq i32 %177, 105
br i1 %178, label %179, label %326
179: ; preds = %172, %165
store i64 1, i64* %11
br label %180
180: ; preds = %322, %179
%181 = load i64, i64* %11
%182 = load i64, i64* %6
%183 = icmp sle i64 %181, %182
br i1 %183, label %184, label %325
184: ; preds = %180
%185 = load i64, i64* %11
%186 = icmp sgt i64 %185, 1
br i1 %186, label %187, label %200
187: ; preds = %184
%188 = load i8**, i8*** %7
%189 = load i64, i64* %11
%190 = getelementptr inbounds i8*, i8** %188, i64 %189
%191 = load i8*, i8** %190
%192 = load i8**, i8*** %7
%193 = load i64, i64* %11
%194 = sub nsw i64 %193, 1
%195 = getelementptr inbounds i8*, i8** %192, i64 %194
%196 = load i8*, i8** %195
%197 = call i64 @strcmp(i8* %191, i8* %196)
%198 = icmp ne i64 %197, 0
br i1 %198, label %200, label %199
199: ; preds = %187
br label %322
200: ; preds = %187, %184
%201 = load i8**, i8*** %7
%202 = load i64, i64* %11
%203 = getelementptr inbounds i8*, i8** %201, i64 %202
%204 = load i8*, i8** %203
%205 = call i64 @strcmp(i8* %204, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%206 = icmp eq i64 %205, 0
br i1 %206, label %221, label %207
207: ; preds = %200
%208 = load i8**, i8*** %7
%209 = load i64, i64* %11
%210 = getelementptr inbounds i8*, i8** %208, i64 %209
%211 = load i8*, i8** %210
%212 = call i64 @strcmp(i8* %211, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%213 = icmp eq i64 %212, 0
br i1 %213, label %221, label %214
214: ; preds = %207
%215 = load i8**, i8*** %7
%216 = load i64, i64* %11
%217 = getelementptr inbounds i8*, i8** %215, i64 %216
%218 = load i8*, i8** %217
%219 = call i64 @strcmp(i8* %218, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%220 = icmp eq i64 %219, 0
br i1 %220, label %221, label %224
221: ; preds = %214, %207, %200
%222 = load i64, i64* %15
%223 = add nsw i64 %222, 1
store i64 %223, i64* %15
br label %224
224: ; preds = %221, %214
%225 = load i8**, i8*** %7
%226 = load i64, i64* %11
%227 = getelementptr inbounds i8*, i8** %225, i64 %226
%228 = load i8*, i8** %227
%229 = call i64 @strcmp(i8* %228, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%230 = icmp eq i64 %229, 0
br i1 %230, label %252, label %231
231: ; preds = %224
%232 = load i8**, i8*** %7
%233 = load i64, i64* %11
%234 = getelementptr inbounds i8*, i8** %232, i64 %233
%235 = load i8*, i8** %234
%236 = call i64 @strcmp(i8* %235, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%237 = icmp eq i64 %236, 0
br i1 %237, label %252, label %238
238: ; preds = %231
%239 = load i8**, i8*** %7
%240 = load i64, i64* %11
%241 = getelementptr inbounds i8*, i8** %239, i64 %240
%242 = load i8*, i8** %241
%243 = call i64 @strcmp(i8* %242, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%244 = icmp eq i64 %243, 0
br i1 %244, label %252, label %245
245: ; preds = %238
%246 = load i8**, i8*** %7
%247 = load i64, i64* %11
%248 = getelementptr inbounds i8*, i8** %246, i64 %247
%249 = load i8*, i8** %248
%250 = call i64 @strcmp(i8* %249, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%251 = icmp eq i64 %250, 0
br i1 %251, label %252, label %255
252: ; preds = %245, %238, %231, %224
%253 = load i64, i64* %16
%254 = add nsw i64 %253, 1
store i64 %254, i64* %16
br label %255
255: ; preds = %252, %245
%256 = load i8**, i8*** %7
%257 = load i64, i64* %11
%258 = getelementptr inbounds i8*, i8** %256, i64 %257
%259 = load i8*, i8** %258
%260 = call i64 @strcmp(i8* %259, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%261 = icmp eq i64 %260, 0
br i1 %261, label %318, label %262
262: ; preds = %255
%263 = load i8**, i8*** %7
%264 = load i64, i64* %11
%265 = getelementptr inbounds i8*, i8** %263, i64 %264
%266 = load i8*, i8** %265
%267 = call i64 @strcmp(i8* %266, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%268 = icmp eq i64 %267, 0
br i1 %268, label %318, label %269
269: ; preds = %262
%270 = load i8**, i8*** %7
%271 = load i64, i64* %11
%272 = getelementptr inbounds i8*, i8** %270, i64 %271
%273 = load i8*, i8** %272
%274 = call i64 @strcmp(i8* %273, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%275 = icmp eq i64 %274, 0
br i1 %275, label %318, label %276
276: ; preds = %269
%277 = load i8**, i8*** %7
%278 = load i64, i64* %11
%279 = getelementptr inbounds i8*, i8** %277, i64 %278
%280 = load i8*, i8** %279
%281 = call i64 @strcmp(i8* %280, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%282 = icmp eq i64 %281, 0
br i1 %282, label %318, label %283
283: ; preds = %276
%284 = load i8**, i8*** %7
%285 = load i64, i64* %11
%286 = getelementptr inbounds i8*, i8** %284, i64 %285
%287 = load i8*, i8** %286
%288 = call i64 @strcmp(i8* %287, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%289 = icmp eq i64 %288, 0
br i1 %289, label %318, label %290
290: ; preds = %283
%291 = load i8**, i8*** %7
%292 = load i64, i64* %11
%293 = getelementptr inbounds i8*, i8** %291, i64 %292
%294 = load i8*, i8** %293
%295 = call i64 @strcmp(i8* %294, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%296 = icmp eq i64 %295, 0
br i1 %296, label %318, label %297
297: ; preds = %290
%298 = load i8**, i8*** %7
%299 = load i64, i64* %11
%300 = getelementptr inbounds i8*, i8** %298, i64 %299
%301 = load i8*, i8** %300
%302 = call i64 @strcmp(i8* %301, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%303 = icmp eq i64 %302, 0
br i1 %303, label %318, label %304
304: ; preds = %297
%305 = load i8**, i8*** %7
%306 = load i64, i64* %11
%307 = getelementptr inbounds i8*, i8** %305, i64 %306
%308 = load i8*, i8** %307
%309 = call i64 @strcmp(i8* %308, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
%310 = icmp eq i64 %309, 0
br i1 %310, label %318, label %311
311: ; preds = %304
%312 = load i8**, i8*** %7
%313 = load i64, i64* %11
%314 = getelementptr inbounds i8*, i8** %312, i64 %313
%315 = load i8*, i8** %314
%316 = call i64 @strcmp(i8* %315, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%317 = icmp eq i64 %316, 0
br i1 %317, label %318, label %321
318: ; preds = %311, %304, %297, %290, %283, %276, %269, %262, %255
%319 = load i64, i64* %17
%320 = add nsw i64 %319, 1
store i64 %320, i64* %17
br label %321
321: ; preds = %318, %311
br label %322
322: ; preds = %321, %199
%323 = load i64, i64* %11
%324 = add nsw i64 %323, 1
store i64 %324, i64* %11
br label %180
325: ; preds = %180
br label %911
326: ; preds = %172
%327 = load i8*, i8** %9
%328 = load i64, i64* %8
%329 = getelementptr inbounds i8, i8* %327, i64 %328
%330 = load i8, i8* %329
%331 = sext i8 %330 to i32
%332 = icmp eq i32 %331, 71
br i1 %332, label %340, label %333
333: ; preds = %326
%334 = load i8*, i8** %9
%335 = load i64, i64* %8
%336 = getelementptr inbounds i8, i8* %334, i64 %335
%337 = load i8, i8* %336
%338 = sext i8 %337 to i32
%339 = icmp eq i32 %338, 103
br i1 %339, label %340, label %473
340: ; preds = %333, %326
store i64 1, i64* %11
br label %341
341: ; preds = %469, %340
%342 = load i64, i64* %11
%343 = load i64, i64* %6
%344 = icmp sle i64 %342, %343
br i1 %344, label %345, label %472
345: ; preds = %341
%346 = load i64, i64* %11
%347 = icmp sgt i64 %346, 1
br i1 %347, label %348, label %361
348: ; preds = %345
%349 = load i8**, i8*** %7
%350 = load i64, i64* %11
%351 = getelementptr inbounds i8*, i8** %349, i64 %350
%352 = load i8*, i8** %351
%353 = load i8**, i8*** %7
%354 = load i64, i64* %11
%355 = sub nsw i64 %354, 1
%356 = getelementptr inbounds i8*, i8** %353, i64 %355
%357 = load i8*, i8** %356
%358 = call i64 @strcmp(i8* %352, i8* %357)
%359 = icmp ne i64 %358, 0
br i1 %359, label %361, label %360
360: ; preds = %348
br label %469
361: ; preds = %348, %345
%362 = load i8**, i8*** %7
%363 = load i64, i64* %11
%364 = getelementptr inbounds i8*, i8** %362, i64 %363
%365 = load i8*, i8** %364
%366 = call i64 @strcmp(i8* %365, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%367 = icmp eq i64 %366, 0
br i1 %367, label %382, label %368
368: ; preds = %361
%369 = load i8**, i8*** %7
%370 = load i64, i64* %11
%371 = getelementptr inbounds i8*, i8** %369, i64 %370
%372 = load i8*, i8** %371
%373 = call i64 @strcmp(i8* %372, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%374 = icmp eq i64 %373, 0
br i1 %374, label %382, label %375
375: ; preds = %368
%376 = load i8**, i8*** %7
%377 = load i64, i64* %11
%378 = getelementptr inbounds i8*, i8** %376, i64 %377
%379 = load i8*, i8** %378
%380 = call i64 @strcmp(i8* %379, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%381 = icmp eq i64 %380, 0
br i1 %381, label %382, label %385
382: ; preds = %375, %368, %361
%383 = load i64, i64* %15
%384 = add nsw i64 %383, 1
store i64 %384, i64* %15
br label %385
385: ; preds = %382, %375
%386 = load i8**, i8*** %7
%387 = load i64, i64* %11
%388 = getelementptr inbounds i8*, i8** %386, i64 %387
%389 = load i8*, i8** %388
%390 = call i64 @strcmp(i8* %389, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%391 = icmp eq i64 %390, 0
br i1 %391, label %413, label %392
392: ; preds = %385
%393 = load i8**, i8*** %7
%394 = load i64, i64* %11
%395 = getelementptr inbounds i8*, i8** %393, i64 %394
%396 = load i8*, i8** %395
%397 = call i64 @strcmp(i8* %396, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%398 = icmp eq i64 %397, 0
br i1 %398, label %413, label %399
399: ; preds = %392
%400 = load i8**, i8*** %7
%401 = load i64, i64* %11
%402 = getelementptr inbounds i8*, i8** %400, i64 %401
%403 = load i8*, i8** %402
%404 = call i64 @strcmp(i8* %403, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%405 = icmp eq i64 %404, 0
br i1 %405, label %413, label %406
406: ; preds = %399
%407 = load i8**, i8*** %7
%408 = load i64, i64* %11
%409 = getelementptr inbounds i8*, i8** %407, i64 %408
%410 = load i8*, i8** %409
%411 = call i64 @strcmp(i8* %410, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%412 = icmp eq i64 %411, 0
br i1 %412, label %413, label %416
413: ; preds = %406, %399, %392, %385
%414 = load i64, i64* %16
%415 = add nsw i64 %414, 1
store i64 %415, i64* %16
br label %416
416: ; preds = %413, %406
%417 = load i8**, i8*** %7
%418 = load i64, i64* %11
%419 = getelementptr inbounds i8*, i8** %417, i64 %418
%420 = load i8*, i8** %419
%421 = call i64 @strcmp(i8* %420, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%422 = icmp eq i64 %421, 0
br i1 %422, label %465, label %423
423: ; preds = %416
%424 = load i8**, i8*** %7
%425 = load i64, i64* %11
%426 = getelementptr inbounds i8*, i8** %424, i64 %425
%427 = load i8*, i8** %426
%428 = call i64 @strcmp(i8* %427, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%429 = icmp eq i64 %428, 0
br i1 %429, label %465, label %430
430: ; preds = %423
%431 = load i8**, i8*** %7
%432 = load i64, i64* %11
%433 = getelementptr inbounds i8*, i8** %431, i64 %432
%434 = load i8*, i8** %433
%435 = call i64 @strcmp(i8* %434, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%436 = icmp eq i64 %435, 0
br i1 %436, label %465, label %437
437: ; preds = %430
%438 = load i8**, i8*** %7
%439 = load i64, i64* %11
%440 = getelementptr inbounds i8*, i8** %438, i64 %439
%441 = load i8*, i8** %440
%442 = call i64 @strcmp(i8* %441, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%443 = icmp eq i64 %442, 0
br i1 %443, label %465, label %444
444: ; preds = %437
%445 = load i8**, i8*** %7
%446 = load i64, i64* %11
%447 = getelementptr inbounds i8*, i8** %445, i64 %446
%448 = load i8*, i8** %447
%449 = call i64 @strcmp(i8* %448, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%450 = icmp eq i64 %449, 0
br i1 %450, label %465, label %451
451: ; preds = %444
%452 = load i8**, i8*** %7
%453 = load i64, i64* %11
%454 = getelementptr inbounds i8*, i8** %452, i64 %453
%455 = load i8*, i8** %454
%456 = call i64 @strcmp(i8* %455, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%457 = icmp eq i64 %456, 0
br i1 %457, label %465, label %458
458: ; preds = %451
%459 = load i8**, i8*** %7
%460 = load i64, i64* %11
%461 = getelementptr inbounds i8*, i8** %459, i64 %460
%462 = load i8*, i8** %461
%463 = call i64 @strcmp(i8* %462, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%464 = icmp eq i64 %463, 0
br i1 %464, label %465, label %468
465: ; preds = %458, %451, %444, %437, %430, %423, %416
%466 = load i64, i64* %17
%467 = add nsw i64 %466, 1
store i64 %467, i64* %17
br label %468
468: ; preds = %465, %458
br label %469
469: ; preds = %468, %360
%470 = load i64, i64* %11
%471 = add nsw i64 %470, 1
store i64 %471, i64* %11
br label %341
472: ; preds = %341
br label %910
473: ; preds = %333
%474 = load i8*, i8** %9
%475 = load i64, i64* %8
%476 = getelementptr inbounds i8, i8* %474, i64 %475
%477 = load i8, i8* %476
%478 = sext i8 %477 to i32
%479 = icmp eq i32 %478, 67
br i1 %479, label %487, label %480
480: ; preds = %473
%481 = load i8*, i8** %9
%482 = load i64, i64* %8
%483 = getelementptr inbounds i8, i8* %481, i64 %482
%484 = load i8, i8* %483
%485 = sext i8 %484 to i32
%486 = icmp eq i32 %485, 99
br i1 %486, label %487, label %613
487: ; preds = %480, %473
store i64 1, i64* %11
br label %488
488: ; preds = %609, %487
%489 = load i64, i64* %11
%490 = load i64, i64* %6
%491 = icmp sle i64 %489, %490
br i1 %491, label %492, label %612
492: ; preds = %488
%493 = load i64, i64* %11
%494 = icmp sgt i64 %493, 1
br i1 %494, label %495, label %508
495: ; preds = %492
%496 = load i8**, i8*** %7
%497 = load i64, i64* %11
%498 = getelementptr inbounds i8*, i8** %496, i64 %497
%499 = load i8*, i8** %498
%500 = load i8**, i8*** %7
%501 = load i64, i64* %11
%502 = sub nsw i64 %501, 1
%503 = getelementptr inbounds i8*, i8** %500, i64 %502
%504 = load i8*, i8** %503
%505 = call i64 @strcmp(i8* %499, i8* %504)
%506 = icmp ne i64 %505, 0
br i1 %506, label %508, label %507
507: ; preds = %495
br label %609
508: ; preds = %495, %492
%509 = load i8**, i8*** %7
%510 = load i64, i64* %11
%511 = getelementptr inbounds i8*, i8** %509, i64 %510
%512 = load i8*, i8** %511
%513 = call i64 @strcmp(i8* %512, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%514 = icmp eq i64 %513, 0
br i1 %514, label %529, label %515
515: ; preds = %508
%516 = load i8**, i8*** %7
%517 = load i64, i64* %11
%518 = getelementptr inbounds i8*, i8** %516, i64 %517
%519 = load i8*, i8** %518
%520 = call i64 @strcmp(i8* %519, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%521 = icmp eq i64 %520, 0
br i1 %521, label %529, label %522
522: ; preds = %515
%523 = load i8**, i8*** %7
%524 = load i64, i64* %11
%525 = getelementptr inbounds i8*, i8** %523, i64 %524
%526 = load i8*, i8** %525
%527 = call i64 @strcmp(i8* %526, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%528 = icmp eq i64 %527, 0
br i1 %528, label %529, label %532
529: ; preds = %522, %515, %508
%530 = load i64, i64* %15
%531 = add nsw i64 %530, 1
store i64 %531, i64* %15
br label %532
532: ; preds = %529, %522
%533 = load i8**, i8*** %7
%534 = load i64, i64* %11
%535 = getelementptr inbounds i8*, i8** %533, i64 %534
%536 = load i8*, i8** %535
%537 = call i64 @strcmp(i8* %536, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%538 = icmp eq i64 %537, 0
br i1 %538, label %553, label %539
539: ; preds = %532
%540 = load i8**, i8*** %7
%541 = load i64, i64* %11
%542 = getelementptr inbounds i8*, i8** %540, i64 %541
%543 = load i8*, i8** %542
%544 = call i64 @strcmp(i8* %543, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%545 = icmp eq i64 %544, 0
br i1 %545, label %553, label %546
546: ; preds = %539
%547 = load i8**, i8*** %7
%548 = load i64, i64* %11
%549 = getelementptr inbounds i8*, i8** %547, i64 %548
%550 = load i8*, i8** %549
%551 = call i64 @strcmp(i8* %550, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%552 = icmp eq i64 %551, 0
br i1 %552, label %553, label %556
553: ; preds = %546, %539, %532
%554 = load i64, i64* %16
%555 = add nsw i64 %554, 1
store i64 %555, i64* %16
br label %556
556: ; preds = %553, %546
%557 = load i8**, i8*** %7
%558 = load i64, i64* %11
%559 = getelementptr inbounds i8*, i8** %557, i64 %558
%560 = load i8*, i8** %559
%561 = call i64 @strcmp(i8* %560, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%562 = icmp eq i64 %561, 0
br i1 %562, label %605, label %563
563: ; preds = %556
%564 = load i8**, i8*** %7
%565 = load i64, i64* %11
%566 = getelementptr inbounds i8*, i8** %564, i64 %565
%567 = load i8*, i8** %566
%568 = call i64 @strcmp(i8* %567, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%569 = icmp eq i64 %568, 0
br i1 %569, label %605, label %570
570: ; preds = %563
%571 = load i8**, i8*** %7
%572 = load i64, i64* %11
%573 = getelementptr inbounds i8*, i8** %571, i64 %572
%574 = load i8*, i8** %573
%575 = call i64 @strcmp(i8* %574, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%576 = icmp eq i64 %575, 0
br i1 %576, label %605, label %577
577: ; preds = %570
%578 = load i8**, i8*** %7
%579 = load i64, i64* %11
%580 = getelementptr inbounds i8*, i8** %578, i64 %579
%581 = load i8*, i8** %580
%582 = call i64 @strcmp(i8* %581, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%583 = icmp eq i64 %582, 0
br i1 %583, label %605, label %584
584: ; preds = %577
%585 = load i8**, i8*** %7
%586 = load i64, i64* %11
%587 = getelementptr inbounds i8*, i8** %585, i64 %586
%588 = load i8*, i8** %587
%589 = call i64 @strcmp(i8* %588, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%590 = icmp eq i64 %589, 0
br i1 %590, label %605, label %591
591: ; preds = %584
%592 = load i8**, i8*** %7
%593 = load i64, i64* %11
%594 = getelementptr inbounds i8*, i8** %592, i64 %593
%595 = load i8*, i8** %594
%596 = call i64 @strcmp(i8* %595, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
%597 = icmp eq i64 %596, 0
br i1 %597, label %605, label %598
598: ; preds = %591
%599 = load i8**, i8*** %7
%600 = load i64, i64* %11
%601 = getelementptr inbounds i8*, i8** %599, i64 %600
%602 = load i8*, i8** %601
%603 = call i64 @strcmp(i8* %602, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%604 = icmp eq i64 %603, 0
br i1 %604, label %605, label %608
605: ; preds = %598, %591, %584, %577, %570, %563, %556
%606 = load i64, i64* %17
%607 = add nsw i64 %606, 1
store i64 %607, i64* %17
br label %608
608: ; preds = %605, %598
br label %609
609: ; preds = %608, %507
%610 = load i64, i64* %11
%611 = add nsw i64 %610, 1
store i64 %611, i64* %11
br label %488
612: ; preds = %488
br label %909
613: ; preds = %480
%614 = load i8*, i8** %9
%615 = load i64, i64* %8
%616 = getelementptr inbounds i8, i8* %614, i64 %615
%617 = load i8, i8* %616
%618 = sext i8 %617 to i32
%619 = icmp eq i32 %618, 85
br i1 %619, label %641, label %620
620: ; preds = %613
%621 = load i8*, i8** %9
%622 = load i64, i64* %8
%623 = getelementptr inbounds i8, i8* %621, i64 %622
%624 = load i8, i8* %623
%625 = sext i8 %624 to i32
%626 = icmp eq i32 %625, 84
br i1 %626, label %641, label %627
627: ; preds = %620
%628 = load i8*, i8** %9
%629 = load i64, i64* %8
%630 = getelementptr inbounds i8, i8* %628, i64 %629
%631 = load i8, i8* %630
%632 = sext i8 %631 to i32
%633 = icmp eq i32 %632, 117
br i1 %633, label %641, label %634
634: ; preds = %627
%635 = load i8*, i8** %9
%636 = load i64, i64* %8
%637 = getelementptr inbounds i8, i8* %635, i64 %636
%638 = load i8, i8* %637
%639 = sext i8 %638 to i32
%640 = icmp eq i32 %639, 116
br i1 %640, label %641, label %767
641: ; preds = %634, %627, %620, %613
store i64 1, i64* %11
br label %642
642: ; preds = %763, %641
%643 = load i64, i64* %11
%644 = load i64, i64* %6
%645 = icmp sle i64 %643, %644
br i1 %645, label %646, label %766
646: ; preds = %642
%647 = load i64, i64* %11
%648 = icmp sgt i64 %647, 1
br i1 %648, label %649, label %662
649: ; preds = %646
%650 = load i8**, i8*** %7
%651 = load i64, i64* %11
%652 = getelementptr inbounds i8*, i8** %650, i64 %651
%653 = load i8*, i8** %652
%654 = load i8**, i8*** %7
%655 = load i64, i64* %11
%656 = sub nsw i64 %655, 1
%657 = getelementptr inbounds i8*, i8** %654, i64 %656
%658 = load i8*, i8** %657
%659 = call i64 @strcmp(i8* %653, i8* %658)
%660 = icmp ne i64 %659, 0
br i1 %660, label %662, label %661
661: ; preds = %649
br label %763
662: ; preds = %649, %646
%663 = load i8**, i8*** %7
%664 = load i64, i64* %11
%665 = getelementptr inbounds i8*, i8** %663, i64 %664
%666 = load i8*, i8** %665
%667 = call i64 @strcmp(i8* %666, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%668 = icmp eq i64 %667, 0
br i1 %668, label %683, label %669
669: ; preds = %662
%670 = load i8**, i8*** %7
%671 = load i64, i64* %11
%672 = getelementptr inbounds i8*, i8** %670, i64 %671
%673 = load i8*, i8** %672
%674 = call i64 @strcmp(i8* %673, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%675 = icmp eq i64 %674, 0
br i1 %675, label %683, label %676
676: ; preds = %669
%677 = load i8**, i8*** %7
%678 = load i64, i64* %11
%679 = getelementptr inbounds i8*, i8** %677, i64 %678
%680 = load i8*, i8** %679
%681 = call i64 @strcmp(i8* %680, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%682 = icmp eq i64 %681, 0
br i1 %682, label %683, label %686
683: ; preds = %676, %669, %662
%684 = load i64, i64* %15
%685 = add nsw i64 %684, 1
store i64 %685, i64* %15
br label %686
686: ; preds = %683, %676
%687 = load i8**, i8*** %7
%688 = load i64, i64* %11
%689 = getelementptr inbounds i8*, i8** %687, i64 %688
%690 = load i8*, i8** %689
%691 = call i64 @strcmp(i8* %690, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%692 = icmp eq i64 %691, 0
br i1 %692, label %707, label %693
693: ; preds = %686
%694 = load i8**, i8*** %7
%695 = load i64, i64* %11
%696 = getelementptr inbounds i8*, i8** %694, i64 %695
%697 = load i8*, i8** %696
%698 = call i64 @strcmp(i8* %697, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%699 = icmp eq i64 %698, 0
br i1 %699, label %707, label %700
700: ; preds = %693
%701 = load i8**, i8*** %7
%702 = load i64, i64* %11
%703 = getelementptr inbounds i8*, i8** %701, i64 %702
%704 = load i8*, i8** %703
%705 = call i64 @strcmp(i8* %704, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%706 = icmp eq i64 %705, 0
br i1 %706, label %707, label %710
707: ; preds = %700, %693, %686
%708 = load i64, i64* %16
%709 = add nsw i64 %708, 1
store i64 %709, i64* %16
br label %710
710: ; preds = %707, %700
%711 = load i8**, i8*** %7
%712 = load i64, i64* %11
%713 = getelementptr inbounds i8*, i8** %711, i64 %712
%714 = load i8*, i8** %713
%715 = call i64 @strcmp(i8* %714, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%716 = icmp eq i64 %715, 0
br i1 %716, label %759, label %717
717: ; preds = %710
%718 = load i8**, i8*** %7
%719 = load i64, i64* %11
%720 = getelementptr inbounds i8*, i8** %718, i64 %719
%721 = load i8*, i8** %720
%722 = call i64 @strcmp(i8* %721, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%723 = icmp eq i64 %722, 0
br i1 %723, label %759, label %724
724: ; preds = %717
%725 = load i8**, i8*** %7
%726 = load i64, i64* %11
%727 = getelementptr inbounds i8*, i8** %725, i64 %726
%728 = load i8*, i8** %727
%729 = call i64 @strcmp(i8* %728, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%730 = icmp eq i64 %729, 0
br i1 %730, label %759, label %731
731: ; preds = %724
%732 = load i8**, i8*** %7
%733 = load i64, i64* %11
%734 = getelementptr inbounds i8*, i8** %732, i64 %733
%735 = load i8*, i8** %734
%736 = call i64 @strcmp(i8* %735, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%737 = icmp eq i64 %736, 0
br i1 %737, label %759, label %738
738: ; preds = %731
%739 = load i8**, i8*** %7
%740 = load i64, i64* %11
%741 = getelementptr inbounds i8*, i8** %739, i64 %740
%742 = load i8*, i8** %741
%743 = call i64 @strcmp(i8* %742, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%744 = icmp eq i64 %743, 0
br i1 %744, label %759, label %745
745: ; preds = %738
%746 = load i8**, i8*** %7
%747 = load i64, i64* %11
%748 = getelementptr inbounds i8*, i8** %746, i64 %747
%749 = load i8*, i8** %748
%750 = call i64 @strcmp(i8* %749, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
%751 = icmp eq i64 %750, 0
br i1 %751, label %759, label %752
752: ; preds = %745
%753 = load i8**, i8*** %7
%754 = load i64, i64* %11
%755 = getelementptr inbounds i8*, i8** %753, i64 %754
%756 = load i8*, i8** %755
%757 = call i64 @strcmp(i8* %756, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%758 = icmp eq i64 %757, 0
br i1 %758, label %759, label %762
759: ; preds = %752, %745, %738, %731, %724, %717, %710
%760 = load i64, i64* %17
%761 = add nsw i64 %760, 1
store i64 %761, i64* %17
br label %762
762: ; preds = %759, %752
br label %763
763: ; preds = %762, %661
%764 = load i64, i64* %11
%765 = add nsw i64 %764, 1
store i64 %765, i64* %11
br label %642
766: ; preds = %642
br label %908
767: ; preds = %634
%768 = load i8*, i8** %9
%769 = load i64, i64* %8
%770 = getelementptr inbounds i8, i8* %768, i64 %769
%771 = load i8, i8* %770
%772 = sext i8 %771 to i32
%773 = icmp eq i32 %772, 80
br i1 %773, label %781, label %774
774: ; preds = %767
%775 = load i8*, i8** %9
%776 = load i64, i64* %8
%777 = getelementptr inbounds i8, i8* %775, i64 %776
%778 = load i8, i8* %777
%779 = sext i8 %778 to i32
%780 = icmp eq i32 %779, 112
br i1 %780, label %781, label %907
781: ; preds = %774, %767
store i64 1, i64* %11
br label %782
782: ; preds = %903, %781
%783 = load i64, i64* %11
%784 = load i64, i64* %6
%785 = icmp sle i64 %783, %784
br i1 %785, label %786, label %906
786: ; preds = %782
%787 = load i64, i64* %11
%788 = icmp sgt i64 %787, 1
br i1 %788, label %789, label %802
789: ; preds = %786
%790 = load i8**, i8*** %7
%791 = load i64, i64* %11
%792 = getelementptr inbounds i8*, i8** %790, i64 %791
%793 = load i8*, i8** %792
%794 = load i8**, i8*** %7
%795 = load i64, i64* %11
%796 = sub nsw i64 %795, 1
%797 = getelementptr inbounds i8*, i8** %794, i64 %796
%798 = load i8*, i8** %797
%799 = call i64 @strcmp(i8* %793, i8* %798)
%800 = icmp ne i64 %799, 0
br i1 %800, label %802, label %801
801: ; preds = %789
br label %903
802: ; preds = %789, %786
%803 = load i8**, i8*** %7
%804 = load i64, i64* %11
%805 = getelementptr inbounds i8*, i8** %803, i64 %804
%806 = load i8*, i8** %805
%807 = call i64 @strcmp(i8* %806, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%808 = icmp eq i64 %807, 0
br i1 %808, label %823, label %809
809: ; preds = %802
%810 = load i8**, i8*** %7
%811 = load i64, i64* %11
%812 = getelementptr inbounds i8*, i8** %810, i64 %811
%813 = load i8*, i8** %812
%814 = call i64 @strcmp(i8* %813, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%815 = icmp eq i64 %814, 0
br i1 %815, label %823, label %816
816: ; preds = %809
%817 = load i8**, i8*** %7
%818 = load i64, i64* %11
%819 = getelementptr inbounds i8*, i8** %817, i64 %818
%820 = load i8*, i8** %819
%821 = call i64 @strcmp(i8* %820, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%822 = icmp eq i64 %821, 0
br i1 %822, label %823, label %826
823: ; preds = %816, %809, %802
%824 = load i64, i64* %15
%825 = add nsw i64 %824, 1
store i64 %825, i64* %15
br label %826
826: ; preds = %823, %816
%827 = load i8**, i8*** %7
%828 = load i64, i64* %11
%829 = getelementptr inbounds i8*, i8** %827, i64 %828
%830 = load i8*, i8** %829
%831 = call i64 @strcmp(i8* %830, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%832 = icmp eq i64 %831, 0
br i1 %832, label %847, label %833
833: ; preds = %826
%834 = load i8**, i8*** %7
%835 = load i64, i64* %11
%836 = getelementptr inbounds i8*, i8** %834, i64 %835
%837 = load i8*, i8** %836
%838 = call i64 @strcmp(i8* %837, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%839 = icmp eq i64 %838, 0
br i1 %839, label %847, label %840
840: ; preds = %833
%841 = load i8**, i8*** %7
%842 = load i64, i64* %11
%843 = getelementptr inbounds i8*, i8** %841, i64 %842
%844 = load i8*, i8** %843
%845 = call i64 @strcmp(i8* %844, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%846 = icmp eq i64 %845, 0
br i1 %846, label %847, label %850
847: ; preds = %840, %833, %826
%848 = load i64, i64* %16
%849 = add nsw i64 %848, 1
store i64 %849, i64* %16
br label %850
850: ; preds = %847, %840
%851 = load i8**, i8*** %7
%852 = load i64, i64* %11
%853 = getelementptr inbounds i8*, i8** %851, i64 %852
%854 = load i8*, i8** %853
%855 = call i64 @strcmp(i8* %854, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%856 = icmp eq i64 %855, 0
br i1 %856, label %899, label %857
857: ; preds = %850
%858 = load i8**, i8*** %7
%859 = load i64, i64* %11
%860 = getelementptr inbounds i8*, i8** %858, i64 %859
%861 = load i8*, i8** %860
%862 = call i64 @strcmp(i8* %861, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%863 = icmp eq i64 %862, 0
br i1 %863, label %899, label %864
864: ; preds = %857
%865 = load i8**, i8*** %7
%866 = load i64, i64* %11
%867 = getelementptr inbounds i8*, i8** %865, i64 %866
%868 = load i8*, i8** %867
%869 = call i64 @strcmp(i8* %868, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%870 = icmp eq i64 %869, 0
br i1 %870, label %899, label %871
871: ; preds = %864
%872 = load i8**, i8*** %7
%873 = load i64, i64* %11
%874 = getelementptr inbounds i8*, i8** %872, i64 %873
%875 = load i8*, i8** %874
%876 = call i64 @strcmp(i8* %875, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%877 = icmp eq i64 %876, 0
br i1 %877, label %899, label %878
878: ; preds = %871
%879 = load i8**, i8*** %7
%880 = load i64, i64* %11
%881 = getelementptr inbounds i8*, i8** %879, i64 %880
%882 = load i8*, i8** %881
%883 = call i64 @strcmp(i8* %882, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%884 = icmp eq i64 %883, 0
br i1 %884, label %899, label %885
885: ; preds = %878
%886 = load i8**, i8*** %7
%887 = load i64, i64* %11
%888 = getelementptr inbounds i8*, i8** %886, i64 %887
%889 = load i8*, i8** %888
%890 = call i64 @strcmp(i8* %889, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
%891 = icmp eq i64 %890, 0
br i1 %891, label %899, label %892
892: ; preds = %885
%893 = load i8**, i8*** %7
%894 = load i64, i64* %11
%895 = getelementptr inbounds i8*, i8** %893, i64 %894
%896 = load i8*, i8** %895
%897 = call i64 @strcmp(i8* %896, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0))
%898 = icmp eq i64 %897, 0
br i1 %898, label %899, label %902
899: ; preds = %892, %885, %878, %871, %864, %857, %850
%900 = load i64, i64* %17
%901 = add nsw i64 %900, 1
store i64 %901, i64* %17
br label %902
902: ; preds = %899, %892
br label %903
903: ; preds = %902, %801
%904 = load i64, i64* %11
%905 = add nsw i64 %904, 1
store i64 %905, i64* %11
br label %782
906: ; preds = %782
br label %907
907: ; preds = %906, %774
br label %908
908: ; preds = %907, %766
br label %909
909: ; preds = %908, %612
br label %910
910: ; preds = %909, %472
br label %911
911: ; preds = %910, %325
br label %912
912: ; preds = %911, %164
%913 = load i64, i64* %15
store i64 %913, i64* %20
%914 = load i64, i64* %16
store i64 %914, i64* %19
%915 = load i64, i64* %17
store i64 %915, i64* %18
%916 = load i64, i64* %15
%917 = load i64, i64* %16
%918 = icmp sge i64 %916, %917
br i1 %918, label %919, label %921
919: ; preds = %912
%920 = load i64, i64* %15
br label %923
921: ; preds = %912
%922 = load i64, i64* %16
br label %923
923: ; preds = %921, %919
%924 = phi i64 [ %920, %919 ], [ %922, %921 ]
store i64 %924, i64* %12
%925 = load i64, i64* %16
%926 = load i64, i64* %17
%927 = icmp sge i64 %925, %926
br i1 %927, label %928, label %930
928: ; preds = %923
%929 = load i64, i64* %16
br label %932
930: ; preds = %923
%931 = load i64, i64* %17
br label %932
932: ; preds = %930, %928
%933 = phi i64 [ %929, %928 ], [ %931, %930 ]
store i64 %933, i64* %13
%934 = load i64, i64* %12
%935 = load i64, i64* %13
%936 = icmp sge i64 %934, %935
br i1 %936, label %937, label %939
937: ; preds = %932
%938 = load i64, i64* %12
br label %941
939: ; preds = %932
%940 = load i64, i64* %13
br label %941
941: ; preds = %939, %937
%942 = phi i64 [ %938, %937 ], [ %940, %939 ]
store i64 %942, i64* %14
%943 = load i64, i64* %15
%944 = load i64, i64* %14
%945 = icmp eq i64 %943, %944
br i1 %945, label %946, label %949
946: ; preds = %941
%947 = load i8*, i8** %10
%948 = call i32 @strcpy(i8* %947, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %965
949: ; preds = %941
%950 = load i64, i64* %16
%951 = load i64, i64* %14
%952 = icmp eq i64 %950, %951
br i1 %952, label %953, label %956
953: ; preds = %949
%954 = load i8*, i8** %10
%955 = call i32 @strcpy(i8* %954, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.21, i64 0, i64 0))
br label %964
956: ; preds = %949
%957 = load i64, i64* %17
%958 = load i64, i64* %14
%959 = icmp eq i64 %957, %958
br i1 %959, label %960, label %963
960: ; preds = %956
%961 = load i8*, i8** %10
%962 = call i32 @strcpy(i8* %961, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
br label %963
963: ; preds = %960, %956
br label %964
964: ; preds = %963, %953
br label %965
965: ; preds = %964, %946
%966 = load i64, i64* %14
%967 = icmp eq i64 %966, 0
br i1 %967, label %968, label %971
968: ; preds = %965
%969 = load i8*, i8** %10
%970 = call i32 @strcpy(i8* %969, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
br label %971
971: ; preds = %968, %965
%972 = load i64, i64* %14
%973 = icmp eq i64 %972, 1
br i1 %973, label %974, label %977
974: ; preds = %971
%975 = load i8*, i8** %10
%976 = call i32 @strcpy(i8* %975, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0))
br label %977
977: ; preds = %974, %971
ret void
}

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