#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 *);
void non_Hbond_pair(long i, long j, long m, long n, char **AtomName, long *RY,
                    long *yes) {
  if (RY[i] == 1 && RY[j] == 1) {
    if ((strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " N7 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " N7 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " N7 ") == 0 &&
         strcmp(AtomName[n], " N7 ") == 0) ||
        (strcmp(AtomName[m], " N7 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " N7 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " N7 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " N7 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0)) {
      *yes = 1;
    }
  } else if (RY[i] == 0 && RY[j] == 0) {
    if ((strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0)) {
      *yes = 1;
    }
  } else if ((RY[i] == 1 && RY[j] == 0)) {
    if ((strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " N9 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " N3 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " O2 ") == 0) ||
        (strcmp(AtomName[m], " O6 ") == 0 &&
         strcmp(AtomName[n], " O4 ") == 0) ||
        (strcmp(AtomName[m], " N7 ") == 0 &&
         strcmp(AtomName[n], " N1 ") == 0)) {
      *yes = 1;
    }
  } else if ((RY[i] == 0 && RY[j] == 1)) {
    if ((strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " O2 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " N9 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " N3 ") == 0) ||
        (strcmp(AtomName[m], " O4 ") == 0 &&
         strcmp(AtomName[n], " O6 ") == 0) ||
        (strcmp(AtomName[m], " N1 ") == 0 &&
         strcmp(AtomName[n], " N7 ") == 0)) {
      *yes = 1;
    }
  }
}


x86 assembly (clang, -O0):
<non_Hbond_pair>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    15aa <non_Hbond_pair+0x49a>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    15aa <non_Hbond_pair+0x49a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe93(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    119e <non_Hbond_pair+0x8e>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe71(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe4f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    11e2 <non_Hbond_pair+0xd2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe32(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe0b(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1226 <non_Hbond_pair+0x116>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdf3(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdc7(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    126a <non_Hbond_pair+0x15a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdb4(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd8d(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    12ae <non_Hbond_pair+0x19e>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd61(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd49(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    12f2 <non_Hbond_pair+0x1e2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd27(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd05(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1336 <non_Hbond_pair+0x226>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcde(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcc1(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    137a <non_Hbond_pair+0x26a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xca4(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc78(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    13be <non_Hbond_pair+0x2ae>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc51(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc34(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1402 <non_Hbond_pair+0x2f2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc17(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbf0(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1446 <non_Hbond_pair+0x336>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbce(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbac(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    148a <non_Hbond_pair+0x37a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb94(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb72(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    14ce <non_Hbond_pair+0x3be>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb41(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb2e(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1512 <non_Hbond_pair+0x402>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb07(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xaea(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1556 <non_Hbond_pair+0x446>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xabe(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     159a <non_Hbond_pair+0x48a>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xaa6(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    15a5 <non_Hbond_pair+0x495>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa84(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    15a5 <non_Hbond_pair+0x495>
mov    0x10(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e0f <non_Hbond_pair+0xcff>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1844 <non_Hbond_pair+0x734>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1844 <non_Hbond_pair+0x734>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa31(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1614 <non_Hbond_pair+0x504>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa0f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9ed(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1658 <non_Hbond_pair+0x548>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9d0(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9a9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    169c <non_Hbond_pair+0x58c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x991(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x96a(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    16e0 <non_Hbond_pair+0x5d0>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x943(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x926(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1724 <non_Hbond_pair+0x614>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x904(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8e2(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1768 <non_Hbond_pair+0x658>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8c5(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8a3(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    17ac <non_Hbond_pair+0x69c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x877(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x85f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    17f0 <non_Hbond_pair+0x6e0>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x838(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1834 <non_Hbond_pair+0x724>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x81b(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    183f <non_Hbond_pair+0x72f>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x7f9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    183f <non_Hbond_pair+0x72f>
mov    0x10(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e0a <non_Hbond_pair+0xcfa>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    1b22 <non_Hbond_pair+0xa12>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1b22 <non_Hbond_pair+0xa12>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x788(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    18ae <non_Hbond_pair+0x79e>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x775(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x744(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    18f2 <non_Hbond_pair+0x7e2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x736(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x700(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1936 <non_Hbond_pair+0x826>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6f7(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6b7(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    197a <non_Hbond_pair+0x86a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6a9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x673(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    19be <non_Hbond_pair+0x8ae>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x66a(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x62f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1a02 <non_Hbond_pair+0x8f2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x62b(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x5fa(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1a46 <non_Hbond_pair+0x936>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x5dd(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x5b6(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1a8a <non_Hbond_pair+0x97a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x59e(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x572(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1ace <non_Hbond_pair+0x9be>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x55f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1b12 <non_Hbond_pair+0xa02>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x529(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1b1d <non_Hbond_pair+0xa0d>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x511(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1b1d <non_Hbond_pair+0xa0d>
mov    0x10(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e05 <non_Hbond_pair+0xcf5>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1e00 <non_Hbond_pair+0xcf0>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    1e00 <non_Hbond_pair+0xcf0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x4b9(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1b8c <non_Hbond_pair+0xa7c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x488(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x475(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1bd0 <non_Hbond_pair+0xac0>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x43f(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x431(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1c14 <non_Hbond_pair+0xb04>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x40a(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x3f2(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1c58 <non_Hbond_pair+0xb48>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x3bc(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x3ae(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1c9c <non_Hbond_pair+0xb8c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x373(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x36a(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1ce0 <non_Hbond_pair+0xbd0>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x33e(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x32b(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1d24 <non_Hbond_pair+0xc14>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2f0(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2e7(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1d68 <non_Hbond_pair+0xc58>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2a7(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2a3(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1dac <non_Hbond_pair+0xc9c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x272(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
je     1df0 <non_Hbond_pair+0xce0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x255(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1dfb <non_Hbond_pair+0xceb>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x229(%rip),%rsi
call   1030 <strcmp@plt>
cmp    $0x0,%rax
jne    1dfb <non_Hbond_pair+0xceb>
mov    0x10(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e00 <non_Hbond_pair+0xcf0>
jmp    1e05 <non_Hbond_pair+0xcf5>
jmp    1e0a <non_Hbond_pair+0xcfa>
jmp    1e0f <non_Hbond_pair+0xcff>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<non_Hbond_pair>:
push   %r15
push   %r14
push   %rbx
mov    %r8,%rbx
mov    %rcx,%r14
mov    %rdx,%r15
mov    (%r9,%rdi,8),%rax
test   %rax,%rax
je     1427 <non_Hbond_pair+0x317>
cmp    $0x1,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%r9,%rsi,8),%rax
test   %rax,%rax
je     15d7 <non_Hbond_pair+0x4c7>
cmp    $0x1,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r15,8),%rdi
lea    0xea9(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    117a <non_Hbond_pair+0x6a>
mov    (%rbx,%r14,8),%rdi
lea    0xe94(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xe7b(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    11a8 <non_Hbond_pair+0x98>
mov    (%rbx,%r14,8),%rdi
lea    0xe6b(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xe4d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    11d6 <non_Hbond_pair+0xc6>
mov    (%rbx,%r14,8),%rdi
lea    0xe42(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xe1f(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1204 <non_Hbond_pair+0xf4>
mov    (%rbx,%r14,8),%rdi
lea    0xe19(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xdfb(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1232 <non_Hbond_pair+0x122>
mov    (%rbx,%r14,8),%rdi
lea    0xddc(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xdcd(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1260 <non_Hbond_pair+0x150>
mov    (%rbx,%r14,8),%rdi
lea    0xdb8(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xd9f(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    128e <non_Hbond_pair+0x17e>
mov    (%rbx,%r14,8),%rdi
lea    0xd85(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xd71(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    12bc <non_Hbond_pair+0x1ac>
mov    (%rbx,%r14,8),%rdi
lea    0xd61(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xd3e(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    12ea <non_Hbond_pair+0x1da>
mov    (%rbx,%r14,8),%rdi
lea    0xd24(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xd10(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1318 <non_Hbond_pair+0x208>
mov    (%rbx,%r14,8),%rdi
lea    0xd00(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xce2(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1346 <non_Hbond_pair+0x236>
mov    (%rbx,%r14,8),%rdi
lea    0xccd(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xcb4(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1374 <non_Hbond_pair+0x264>
mov    (%rbx,%r14,8),%rdi
lea    0xca9(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xc90(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    13a2 <non_Hbond_pair+0x292>
mov    (%rbx,%r14,8),%rdi
lea    0xc6c(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xc62(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    13d0 <non_Hbond_pair+0x2c0>
mov    (%rbx,%r14,8),%rdi
lea    0xc48(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xc34(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    13fe <non_Hbond_pair+0x2ee>
mov    (%rbx,%r14,8),%rdi
lea    0xc15(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xc06(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r14,8),%rdi
lea    0xbed(%rip),%rsi
jmp    1950 <non_Hbond_pair+0x840>
mov    (%r9,%rsi,8),%rax
cmp    $0x1,%rax
je     179e <non_Hbond_pair+0x68e>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r15,8),%rdi
lea    0xbcb(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    146c <non_Hbond_pair+0x35c>
mov    (%rbx,%r14,8),%rdi
lea    0xbb6(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xb9d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    149a <non_Hbond_pair+0x38a>
mov    (%rbx,%r14,8),%rdi
lea    0xb8d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xb6f(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    14c8 <non_Hbond_pair+0x3b8>
mov    (%rbx,%r14,8),%rdi
lea    0xb64(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xb46(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    14f6 <non_Hbond_pair+0x3e6>
mov    (%rbx,%r14,8),%rdi
lea    0xb2c(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xb18(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1524 <non_Hbond_pair+0x414>
mov    (%rbx,%r14,8),%rdi
lea    0xb03(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xaea(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1552 <non_Hbond_pair+0x442>
mov    (%rbx,%r14,8),%rdi
lea    0xada(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xac1(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1580 <non_Hbond_pair+0x470>
mov    (%rbx,%r14,8),%rdi
lea    0xaa2(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xa93(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    15ae <non_Hbond_pair+0x49e>
mov    (%rbx,%r14,8),%rdi
lea    0xa79(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0xa65(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r14,8),%rdi
lea    0xa4c(%rip),%rsi
jmp    1950 <non_Hbond_pair+0x840>
mov    (%rbx,%r15,8),%rdi
lea    0xa23(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1605 <non_Hbond_pair+0x4f5>
mov    (%rbx,%r14,8),%rdi
lea    0xa1d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x9f5(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1633 <non_Hbond_pair+0x523>
mov    (%rbx,%r14,8),%rdi
lea    0x9f4(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x9c7(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1661 <non_Hbond_pair+0x551>
mov    (%rbx,%r14,8),%rdi
lea    0x9cb(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x994(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    168f <non_Hbond_pair+0x57f>
mov    (%rbx,%r14,8),%rdi
lea    0x993(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x966(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    16bd <non_Hbond_pair+0x5ad>
mov    (%rbx,%r14,8),%rdi
lea    0x96a(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x938(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    16eb <non_Hbond_pair+0x5db>
mov    (%rbx,%r14,8),%rdi
lea    0x941(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x919(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1719 <non_Hbond_pair+0x609>
mov    (%rbx,%r14,8),%rdi
lea    0x909(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x8eb(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1747 <non_Hbond_pair+0x637>
mov    (%rbx,%r14,8),%rdi
lea    0x8e0(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x8bd(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1775 <non_Hbond_pair+0x665>
mov    (%rbx,%r14,8),%rdi
lea    0x8b7(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x88a(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r14,8),%rdi
lea    0x87b(%rip),%rsi
jmp    1950 <non_Hbond_pair+0x840>
mov    (%rbx,%r15,8),%rdi
lea    0x86b(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    17cc <non_Hbond_pair+0x6bc>
mov    (%rbx,%r14,8),%rdi
lea    0x847(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x83d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    17fa <non_Hbond_pair+0x6ea>
mov    (%rbx,%r14,8),%rdi
lea    0x814(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x80f(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1828 <non_Hbond_pair+0x718>
mov    (%rbx,%r14,8),%rdi
lea    0x7f5(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x7e6(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1856 <non_Hbond_pair+0x746>
mov    (%rbx,%r14,8),%rdi
lea    0x7bd(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x7b8(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1884 <non_Hbond_pair+0x774>
mov    (%rbx,%r14,8),%rdi
lea    0x78a(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x78a(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    18b2 <non_Hbond_pair+0x7a2>
mov    (%rbx,%r14,8),%rdi
lea    0x76b(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x761(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    18dc <non_Hbond_pair+0x7cc>
mov    (%rbx,%r14,8),%rdi
lea    0x733(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x737(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1906 <non_Hbond_pair+0x7f6>
mov    (%rbx,%r14,8),%rdi
lea    0x704(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x70d(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1930 <non_Hbond_pair+0x820>
mov    (%rbx,%r14,8),%rdi
lea    0x6e9(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
je     195a <non_Hbond_pair+0x84a>
mov    (%rbx,%r15,8),%rdi
lea    0x6d9(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    (%rbx,%r14,8),%rdi
lea    0x6ba(%rip),%rsi
call   1030 <strcmp@plt>
test   %rax,%rax
jne    1966 <non_Hbond_pair+0x856>
mov    0x20(%rsp),%rax
movq   $0x1,(%rax)
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@.str = [5 x i8] c" N3 \00"
@.str.1 = [5 x i8] c" N9 \00"
@.str.2 = [5 x i8] c" N7 \00"
@.str.3 = [5 x i8] c" O6 \00"
@.str.4 = [5 x i8] c" N1 \00"
@.str.5 = [5 x i8] c" O2 \00"
@.str.6 = [5 x i8] c" O4 \00"
define void @non_Hbond_pair(i64 %0, i64 %1, i64 %2, i64 %3, i8** %4, i64* nocapture %5, i64* nocapture writeonly %6) {
%8 = getelementptr inbounds i64, i64* %5, i64 %0
%9 = load i64, i64* %8
switch i64 %9, label %426 [
i64 1, label %10
i64 0, label %158
]
10: ; preds = %7
%11 = getelementptr inbounds i64, i64* %5, i64 %1
%12 = load i64, i64* %11
switch i64 %12, label %426 [
i64 1, label %13
i64 0, label %243
]
13: ; preds = %10
%14 = getelementptr inbounds i8*, i8** %4, i64 %2
%15 = load i8*, i8** %14
%16 = tail call i64 @strcmp(i8* %15, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%17 = icmp eq i64 %16, 0
br i1 %17, label %18, label %23
18: ; preds = %13
%19 = getelementptr inbounds i8*, i8** %4, i64 %3
%20 = load i8*, i8** %19
%21 = tail call i64 @strcmp(i8* %20, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%22 = icmp eq i64 %21, 0
br i1 %22, label %425, label %23
23: ; preds = %18, %13
%24 = load i8*, i8** %14
%25 = tail call i64 @strcmp(i8* %24, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%26 = icmp eq i64 %25, 0
br i1 %26, label %27, label %32
27: ; preds = %23
%28 = getelementptr inbounds i8*, i8** %4, i64 %3
%29 = load i8*, i8** %28
%30 = tail call i64 @strcmp(i8* %29, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%31 = icmp eq i64 %30, 0
br i1 %31, label %425, label %32
32: ; preds = %27, %23
%33 = load i8*, i8** %14
%34 = tail call i64 @strcmp(i8* %33, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%35 = icmp eq i64 %34, 0
br i1 %35, label %36, label %41
36: ; preds = %32
%37 = getelementptr inbounds i8*, i8** %4, i64 %3
%38 = load i8*, i8** %37
%39 = tail call i64 @strcmp(i8* %38, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%40 = icmp eq i64 %39, 0
br i1 %40, label %425, label %41
41: ; preds = %36, %32
%42 = load i8*, i8** %14
%43 = tail call i64 @strcmp(i8* %42, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%44 = icmp eq i64 %43, 0
br i1 %44, label %45, label %50
45: ; preds = %41
%46 = getelementptr inbounds i8*, i8** %4, i64 %3
%47 = load i8*, i8** %46
%48 = tail call i64 @strcmp(i8* %47, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%49 = icmp eq i64 %48, 0
br i1 %49, label %425, label %50
50: ; preds = %45, %41
%51 = load i8*, i8** %14
%52 = tail call i64 @strcmp(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%53 = icmp eq i64 %52, 0
br i1 %53, label %54, label %59
54: ; preds = %50
%55 = getelementptr inbounds i8*, i8** %4, i64 %3
%56 = load i8*, i8** %55
%57 = tail call i64 @strcmp(i8* %56, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%58 = icmp eq i64 %57, 0
br i1 %58, label %425, label %59
59: ; preds = %54, %50
%60 = load i8*, i8** %14
%61 = tail call i64 @strcmp(i8* %60, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%62 = icmp eq i64 %61, 0
br i1 %62, label %63, label %68
63: ; preds = %59
%64 = getelementptr inbounds i8*, i8** %4, i64 %3
%65 = load i8*, i8** %64
%66 = tail call i64 @strcmp(i8* %65, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%67 = icmp eq i64 %66, 0
br i1 %67, label %425, label %68
68: ; preds = %63, %59
%69 = load i8*, i8** %14
%70 = tail call i64 @strcmp(i8* %69, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%71 = icmp eq i64 %70, 0
br i1 %71, label %72, label %77
72: ; preds = %68
%73 = getelementptr inbounds i8*, i8** %4, i64 %3
%74 = load i8*, i8** %73
%75 = tail call i64 @strcmp(i8* %74, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%76 = icmp eq i64 %75, 0
br i1 %76, label %425, label %77
77: ; preds = %72, %68
%78 = load i8*, i8** %14
%79 = tail call i64 @strcmp(i8* %78, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%80 = icmp eq i64 %79, 0
br i1 %80, label %81, label %86
81: ; preds = %77
%82 = getelementptr inbounds i8*, i8** %4, i64 %3
%83 = load i8*, i8** %82
%84 = tail call i64 @strcmp(i8* %83, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%85 = icmp eq i64 %84, 0
br i1 %85, label %425, label %86
86: ; preds = %81, %77
%87 = load i8*, i8** %14
%88 = tail call i64 @strcmp(i8* %87, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%89 = icmp eq i64 %88, 0
br i1 %89, label %90, label %95
90: ; preds = %86
%91 = getelementptr inbounds i8*, i8** %4, i64 %3
%92 = load i8*, i8** %91
%93 = tail call i64 @strcmp(i8* %92, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%94 = icmp eq i64 %93, 0
br i1 %94, label %425, label %95
95: ; preds = %90, %86
%96 = load i8*, i8** %14
%97 = tail call i64 @strcmp(i8* %96, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%98 = icmp eq i64 %97, 0
br i1 %98, label %99, label %104
99: ; preds = %95
%100 = getelementptr inbounds i8*, i8** %4, i64 %3
%101 = load i8*, i8** %100
%102 = tail call i64 @strcmp(i8* %101, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%103 = icmp eq i64 %102, 0
br i1 %103, label %425, label %104
104: ; preds = %99, %95
%105 = load i8*, i8** %14
%106 = tail call i64 @strcmp(i8* %105, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%107 = icmp eq i64 %106, 0
br i1 %107, label %108, label %113
108: ; preds = %104
%109 = getelementptr inbounds i8*, i8** %4, i64 %3
%110 = load i8*, i8** %109
%111 = tail call i64 @strcmp(i8* %110, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%112 = icmp eq i64 %111, 0
br i1 %112, label %425, label %113
113: ; preds = %108, %104
%114 = load i8*, i8** %14
%115 = tail call i64 @strcmp(i8* %114, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%116 = icmp eq i64 %115, 0
br i1 %116, label %117, label %122
117: ; preds = %113
%118 = getelementptr inbounds i8*, i8** %4, i64 %3
%119 = load i8*, i8** %118
%120 = tail call i64 @strcmp(i8* %119, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%121 = icmp eq i64 %120, 0
br i1 %121, label %425, label %122
122: ; preds = %117, %113
%123 = load i8*, i8** %14
%124 = tail call i64 @strcmp(i8* %123, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%125 = icmp eq i64 %124, 0
br i1 %125, label %126, label %131
126: ; preds = %122
%127 = getelementptr inbounds i8*, i8** %4, i64 %3
%128 = load i8*, i8** %127
%129 = tail call i64 @strcmp(i8* %128, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%130 = icmp eq i64 %129, 0
br i1 %130, label %425, label %131
131: ; preds = %126, %122
%132 = load i8*, i8** %14
%133 = tail call i64 @strcmp(i8* %132, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%134 = icmp eq i64 %133, 0
br i1 %134, label %135, label %140
135: ; preds = %131
%136 = getelementptr inbounds i8*, i8** %4, i64 %3
%137 = load i8*, i8** %136
%138 = tail call i64 @strcmp(i8* %137, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%139 = icmp eq i64 %138, 0
br i1 %139, label %425, label %140
140: ; preds = %135, %131
%141 = load i8*, i8** %14
%142 = tail call i64 @strcmp(i8* %141, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%143 = icmp eq i64 %142, 0
br i1 %143, label %144, label %149
144: ; preds = %140
%145 = getelementptr inbounds i8*, i8** %4, i64 %3
%146 = load i8*, i8** %145
%147 = tail call i64 @strcmp(i8* %146, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%148 = icmp eq i64 %147, 0
br i1 %148, label %425, label %149
149: ; preds = %144, %140
%150 = load i8*, i8** %14
%151 = tail call i64 @strcmp(i8* %150, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%152 = icmp eq i64 %151, 0
br i1 %152, label %153, label %426
153: ; preds = %149
%154 = getelementptr inbounds i8*, i8** %4, i64 %3
%155 = load i8*, i8** %154
%156 = tail call i64 @strcmp(i8* %155, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%157 = icmp eq i64 %156, 0
br i1 %157, label %425, label %426
158: ; preds = %7
%159 = getelementptr inbounds i64, i64* %5, i64 %1
%160 = load i64, i64* %159
switch i64 %160, label %426 [
i64 0, label %161
i64 1, label %334
]
161: ; preds = %158
%162 = getelementptr inbounds i8*, i8** %4, i64 %2
%163 = load i8*, i8** %162
%164 = tail call i64 @strcmp(i8* %163, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%165 = icmp eq i64 %164, 0
br i1 %165, label %166, label %171
166: ; preds = %161
%167 = getelementptr inbounds i8*, i8** %4, i64 %3
%168 = load i8*, i8** %167
%169 = tail call i64 @strcmp(i8* %168, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%170 = icmp eq i64 %169, 0
br i1 %170, label %425, label %171
171: ; preds = %166, %161
%172 = load i8*, i8** %162
%173 = tail call i64 @strcmp(i8* %172, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%174 = icmp eq i64 %173, 0
br i1 %174, label %175, label %180
175: ; preds = %171
%176 = getelementptr inbounds i8*, i8** %4, i64 %3
%177 = load i8*, i8** %176
%178 = tail call i64 @strcmp(i8* %177, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%179 = icmp eq i64 %178, 0
br i1 %179, label %425, label %180
180: ; preds = %175, %171
%181 = load i8*, i8** %162
%182 = tail call i64 @strcmp(i8* %181, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%183 = icmp eq i64 %182, 0
br i1 %183, label %184, label %189
184: ; preds = %180
%185 = getelementptr inbounds i8*, i8** %4, i64 %3
%186 = load i8*, i8** %185
%187 = tail call i64 @strcmp(i8* %186, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%188 = icmp eq i64 %187, 0
br i1 %188, label %425, label %189
189: ; preds = %184, %180
%190 = load i8*, i8** %162
%191 = tail call i64 @strcmp(i8* %190, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%192 = icmp eq i64 %191, 0
br i1 %192, label %193, label %198
193: ; preds = %189
%194 = getelementptr inbounds i8*, i8** %4, i64 %3
%195 = load i8*, i8** %194
%196 = tail call i64 @strcmp(i8* %195, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%197 = icmp eq i64 %196, 0
br i1 %197, label %425, label %198
198: ; preds = %193, %189
%199 = load i8*, i8** %162
%200 = tail call i64 @strcmp(i8* %199, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%201 = icmp eq i64 %200, 0
br i1 %201, label %202, label %207
202: ; preds = %198
%203 = getelementptr inbounds i8*, i8** %4, i64 %3
%204 = load i8*, i8** %203
%205 = tail call i64 @strcmp(i8* %204, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%206 = icmp eq i64 %205, 0
br i1 %206, label %425, label %207
207: ; preds = %202, %198
%208 = load i8*, i8** %162
%209 = tail call i64 @strcmp(i8* %208, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%210 = icmp eq i64 %209, 0
br i1 %210, label %211, label %216
211: ; preds = %207
%212 = getelementptr inbounds i8*, i8** %4, i64 %3
%213 = load i8*, i8** %212
%214 = tail call i64 @strcmp(i8* %213, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%215 = icmp eq i64 %214, 0
br i1 %215, label %425, label %216
216: ; preds = %211, %207
%217 = load i8*, i8** %162
%218 = tail call i64 @strcmp(i8* %217, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%219 = icmp eq i64 %218, 0
br i1 %219, label %220, label %225
220: ; preds = %216
%221 = getelementptr inbounds i8*, i8** %4, i64 %3
%222 = load i8*, i8** %221
%223 = tail call i64 @strcmp(i8* %222, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%224 = icmp eq i64 %223, 0
br i1 %224, label %425, label %225
225: ; preds = %220, %216
%226 = load i8*, i8** %162
%227 = tail call i64 @strcmp(i8* %226, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%228 = icmp eq i64 %227, 0
br i1 %228, label %229, label %234
229: ; preds = %225
%230 = getelementptr inbounds i8*, i8** %4, i64 %3
%231 = load i8*, i8** %230
%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 %425, label %234
234: ; preds = %229, %225
%235 = load i8*, i8** %162
%236 = tail call i64 @strcmp(i8* %235, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%237 = icmp eq i64 %236, 0
br i1 %237, label %238, label %426
238: ; preds = %234
%239 = getelementptr inbounds i8*, i8** %4, i64 %3
%240 = load i8*, i8** %239
%241 = tail call i64 @strcmp(i8* %240, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%242 = icmp eq i64 %241, 0
br i1 %242, label %425, label %426
243: ; preds = %10
%244 = getelementptr inbounds i8*, i8** %4, i64 %2
%245 = load i8*, i8** %244
%246 = tail call i64 @strcmp(i8* %245, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%247 = icmp eq i64 %246, 0
br i1 %247, label %248, label %253
248: ; preds = %243
%249 = getelementptr inbounds i8*, i8** %4, i64 %3
%250 = load i8*, i8** %249
%251 = tail call i64 @strcmp(i8* %250, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%252 = icmp eq i64 %251, 0
br i1 %252, label %425, label %253
253: ; preds = %248, %243
%254 = load i8*, i8** %244
%255 = tail call i64 @strcmp(i8* %254, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%256 = icmp eq i64 %255, 0
br i1 %256, label %257, label %262
257: ; preds = %253
%258 = getelementptr inbounds i8*, i8** %4, i64 %3
%259 = load i8*, i8** %258
%260 = tail call i64 @strcmp(i8* %259, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%261 = icmp eq i64 %260, 0
br i1 %261, label %425, label %262
262: ; preds = %257, %253
%263 = load i8*, i8** %244
%264 = tail call i64 @strcmp(i8* %263, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%265 = icmp eq i64 %264, 0
br i1 %265, label %266, label %271
266: ; preds = %262
%267 = getelementptr inbounds i8*, i8** %4, i64 %3
%268 = load i8*, i8** %267
%269 = tail call i64 @strcmp(i8* %268, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%270 = icmp eq i64 %269, 0
br i1 %270, label %425, label %271
271: ; preds = %266, %262
%272 = load i8*, i8** %244
%273 = tail call i64 @strcmp(i8* %272, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%274 = icmp eq i64 %273, 0
br i1 %274, label %275, label %280
275: ; preds = %271
%276 = getelementptr inbounds i8*, i8** %4, i64 %3
%277 = load i8*, i8** %276
%278 = tail call i64 @strcmp(i8* %277, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%279 = icmp eq i64 %278, 0
br i1 %279, label %425, label %280
280: ; preds = %275, %271
%281 = load i8*, i8** %244
%282 = tail call i64 @strcmp(i8* %281, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%283 = icmp eq i64 %282, 0
br i1 %283, label %284, label %289
284: ; preds = %280
%285 = getelementptr inbounds i8*, i8** %4, i64 %3
%286 = load i8*, i8** %285
%287 = tail call i64 @strcmp(i8* %286, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%288 = icmp eq i64 %287, 0
br i1 %288, label %425, label %289
289: ; preds = %284, %280
%290 = load i8*, i8** %244
%291 = tail call i64 @strcmp(i8* %290, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%292 = icmp eq i64 %291, 0
br i1 %292, label %293, label %298
293: ; preds = %289
%294 = getelementptr inbounds i8*, i8** %4, i64 %3
%295 = load i8*, i8** %294
%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 %425, label %298
298: ; preds = %293, %289
%299 = load i8*, i8** %244
%300 = tail call i64 @strcmp(i8* %299, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%301 = icmp eq i64 %300, 0
br i1 %301, label %302, label %307
302: ; preds = %298
%303 = getelementptr inbounds i8*, i8** %4, i64 %3
%304 = load i8*, i8** %303
%305 = tail call i64 @strcmp(i8* %304, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%306 = icmp eq i64 %305, 0
br i1 %306, label %425, label %307
307: ; preds = %302, %298
%308 = load i8*, i8** %244
%309 = tail call i64 @strcmp(i8* %308, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%310 = icmp eq i64 %309, 0
br i1 %310, label %311, label %316
311: ; preds = %307
%312 = getelementptr inbounds i8*, i8** %4, i64 %3
%313 = load i8*, i8** %312
%314 = tail call i64 @strcmp(i8* %313, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%315 = icmp eq i64 %314, 0
br i1 %315, label %425, label %316
316: ; preds = %311, %307
%317 = load i8*, i8** %244
%318 = tail call i64 @strcmp(i8* %317, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%319 = icmp eq i64 %318, 0
br i1 %319, label %320, label %325
320: ; preds = %316
%321 = getelementptr inbounds i8*, i8** %4, i64 %3
%322 = load i8*, i8** %321
%323 = tail call i64 @strcmp(i8* %322, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%324 = icmp eq i64 %323, 0
br i1 %324, label %425, label %325
325: ; preds = %320, %316
%326 = load i8*, i8** %244
%327 = tail call i64 @strcmp(i8* %326, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%328 = icmp eq i64 %327, 0
br i1 %328, label %329, label %426
329: ; preds = %325
%330 = getelementptr inbounds i8*, i8** %4, i64 %3
%331 = load i8*, i8** %330
%332 = tail call i64 @strcmp(i8* %331, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%333 = icmp eq i64 %332, 0
br i1 %333, label %425, label %426
334: ; preds = %158
%335 = getelementptr inbounds i8*, i8** %4, i64 %2
%336 = load i8*, i8** %335
%337 = tail call i64 @strcmp(i8* %336, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%338 = icmp eq i64 %337, 0
br i1 %338, label %339, label %344
339: ; preds = %334
%340 = getelementptr inbounds i8*, i8** %4, i64 %3
%341 = load i8*, i8** %340
%342 = tail call i64 @strcmp(i8* %341, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%343 = icmp eq i64 %342, 0
br i1 %343, label %425, label %344
344: ; preds = %339, %334
%345 = load i8*, i8** %335
%346 = tail call i64 @strcmp(i8* %345, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%347 = icmp eq i64 %346, 0
br i1 %347, label %348, label %353
348: ; preds = %344
%349 = getelementptr inbounds i8*, i8** %4, i64 %3
%350 = load i8*, i8** %349
%351 = tail call i64 @strcmp(i8* %350, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%352 = icmp eq i64 %351, 0
br i1 %352, label %425, label %353
353: ; preds = %348, %344
%354 = load i8*, i8** %335
%355 = tail call i64 @strcmp(i8* %354, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%356 = icmp eq i64 %355, 0
br i1 %356, label %357, label %362
357: ; preds = %353
%358 = getelementptr inbounds i8*, i8** %4, i64 %3
%359 = load i8*, i8** %358
%360 = tail call i64 @strcmp(i8* %359, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%361 = icmp eq i64 %360, 0
br i1 %361, label %425, label %362
362: ; preds = %357, %353
%363 = load i8*, i8** %335
%364 = tail call i64 @strcmp(i8* %363, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%365 = icmp eq i64 %364, 0
br i1 %365, label %366, label %371
366: ; preds = %362
%367 = getelementptr inbounds i8*, i8** %4, i64 %3
%368 = load i8*, i8** %367
%369 = tail call i64 @strcmp(i8* %368, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%370 = icmp eq i64 %369, 0
br i1 %370, label %425, label %371
371: ; preds = %366, %362
%372 = load i8*, i8** %335
%373 = tail call i64 @strcmp(i8* %372, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%374 = icmp eq i64 %373, 0
br i1 %374, label %375, label %380
375: ; preds = %371
%376 = getelementptr inbounds i8*, i8** %4, i64 %3
%377 = load i8*, i8** %376
%378 = tail call i64 @strcmp(i8* %377, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%379 = icmp eq i64 %378, 0
br i1 %379, label %425, label %380
380: ; preds = %375, %371
%381 = load i8*, i8** %335
%382 = tail call i64 @strcmp(i8* %381, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%383 = icmp eq i64 %382, 0
br i1 %383, label %384, label %389
384: ; preds = %380
%385 = getelementptr inbounds i8*, i8** %4, i64 %3
%386 = load i8*, i8** %385
%387 = tail call i64 @strcmp(i8* %386, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%388 = icmp eq i64 %387, 0
br i1 %388, label %425, label %389
389: ; preds = %384, %380
%390 = load i8*, i8** %335
%391 = tail call i64 @strcmp(i8* %390, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%392 = icmp eq i64 %391, 0
br i1 %392, label %393, label %398
393: ; preds = %389
%394 = getelementptr inbounds i8*, i8** %4, i64 %3
%395 = load i8*, i8** %394
%396 = tail call i64 @strcmp(i8* %395, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%397 = icmp eq i64 %396, 0
br i1 %397, label %425, label %398
398: ; preds = %393, %389
%399 = load i8*, i8** %335
%400 = tail call i64 @strcmp(i8* %399, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%401 = icmp eq i64 %400, 0
br i1 %401, label %402, label %407
402: ; preds = %398
%403 = getelementptr inbounds i8*, i8** %4, i64 %3
%404 = load i8*, i8** %403
%405 = tail call i64 @strcmp(i8* %404, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%406 = icmp eq i64 %405, 0
br i1 %406, label %425, label %407
407: ; preds = %402, %398
%408 = load i8*, i8** %335
%409 = tail call i64 @strcmp(i8* %408, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%410 = icmp eq i64 %409, 0
br i1 %410, label %411, label %416
411: ; preds = %407
%412 = getelementptr inbounds i8*, i8** %4, i64 %3
%413 = load i8*, i8** %412
%414 = tail call i64 @strcmp(i8* %413, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%415 = icmp eq i64 %414, 0
br i1 %415, label %425, label %416
416: ; preds = %411, %407
%417 = load i8*, i8** %335
%418 = tail call i64 @strcmp(i8* %417, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%419 = icmp eq i64 %418, 0
br i1 %419, label %420, label %426
420: ; preds = %416
%421 = getelementptr inbounds i8*, i8** %4, i64 %3
%422 = load i8*, i8** %421
%423 = tail call i64 @strcmp(i8* %422, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%424 = icmp eq i64 %423, 0
br i1 %424, label %425, label %426
425: ; preds = %339, %348, %357, %366, %375, %384, %393, %402, %411, %420, %248, %257, %266, %275, %284, %293, %302, %311, %320, %329, %166, %175, %184, %193, %202, %211, %220, %229, %238, %18, %27, %36, %45, %54, %63, %72, %81, %90, %99, %108, %117, %126, %135, %144, %153
store i64 1, i64* %6
br label %426
426: ; preds = %425, %158, %10, %7, %238, %234, %420, %416, %325, %329, %149, %153
ret void
}