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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ nrerror(char *);
int /*<<< orphan*/ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
char toupper(char);
double veclen(double *);
void base_base_dist(long i, long j, long **seidx, char **AtomName, char *bseq,
                    double **xyz, double dist, long *nh, char **hb_atom1,
                    char **hb_atom2, double *hb_dist) {
  double dd, dtmp[4];
  long k, m, n, num_hbonds = 0;
  for (m = seidx[i][1]; m <= seidx[i][2]; m++) {
    if (!strcmp(AtomName[m], " O3'") || !strcmp(AtomName[m], " O2P") ||
        !strcmp(AtomName[m], " O5'") || !strcmp(AtomName[m], " O1P"))
      continue;
    if ((AtomName[m][1] == 'C' && AtomName[m][3] == '\'') ||
        AtomName[m][1] == 'P')
      continue;
    if (toupper(bseq[i]) == 'A' || toupper(bseq[i]) == 'I') {
      if (!strcmp(AtomName[m], " C4 ") || !strcmp(AtomName[m], " C5 ") ||
          !strcmp(AtomName[m], " C6 "))
        continue;
    } else if (toupper(bseq[i]) == 'G') {
      if (!strcmp(AtomName[m], " C4 ") || !strcmp(AtomName[m], " C5 ") ||
          !strcmp(AtomName[m], " C6 ") || !strcmp(AtomName[m], " C2 "))
        continue;
    } else if (toupper(bseq[i]) == 'P') {
      if (!strcmp(AtomName[m], " C4 ") || !strcmp(AtomName[m], " C5 "))
        continue;
    } else if (toupper(bseq[i]) == 'U' || toupper(bseq[i]) == 'C' ||
               toupper(bseq[i]) == 'T') {
      if (!strcmp(AtomName[m], " C4 ") || !strcmp(AtomName[m], " C2 "))
        continue;
    }
    for (n = seidx[j][1]; n <= seidx[j][2]; n++) {
      if (!strcmp(AtomName[n], " O3'") || !strcmp(AtomName[n], " O2P") ||
          !strcmp(AtomName[n], " O5'") || !strcmp(AtomName[n], " O1P"))
        continue;
      if ((AtomName[n][1] == 'C' && AtomName[n][3] == '\'') ||
          AtomName[n][1] == 'P')
        continue;
      if (toupper(bseq[j]) == 'A' || toupper(bseq[j]) == 'I') {
        if (!strcmp(AtomName[n], " C4 ") || !strcmp(AtomName[n], " C5 ") ||
            !strcmp(AtomName[n], " C6 "))
          continue;
      } else if (toupper(bseq[j]) == 'G') {
        if (!strcmp(AtomName[n], " C4 ") || !strcmp(AtomName[n], " C5 ") ||
            !strcmp(AtomName[n], " C6 ") || !strcmp(AtomName[n], " C2 "))
          continue;
      } else if (toupper(bseq[j]) == 'P') {
        if (!strcmp(AtomName[n], " C4 ") || !strcmp(AtomName[n], " C5 "))
          continue;
      } else if (toupper(bseq[j]) == 'U' || toupper(bseq[j]) == 'C' ||
                 toupper(bseq[j]) == 'T') {
        if (!strcmp(AtomName[n], " C4 ") || !strcmp(AtomName[n], " C2 "))
          continue;
      }
      if (AtomName[m][1] == 'C' && AtomName[n][1] == 'C')
        continue;
      if ((!strcmp(AtomName[m], " O3'") || !strcmp(AtomName[m], " O4'") ||
           !strcmp(AtomName[m], " O5'") || !strcmp(AtomName[m], " O1P") ||
           !strcmp(AtomName[m], " O2P")) &&
          (!strcmp(AtomName[n], " O3'") || !strcmp(AtomName[n], " O4'") ||
           !strcmp(AtomName[n], " O5'") || !strcmp(AtomName[n], " O1P") ||
           !strcmp(AtomName[n], " O2P")))
        continue;
      for (k = 1; k <= 3; k++) {
        dtmp[k] = xyz[m][k] - xyz[n][k];
      }
      if ((dd = veclen(dtmp)) < dist) {
        if (++num_hbonds > 512)
          nrerror("Too many possible H-bonds between two bases");
        strcpy(hb_atom1[num_hbonds], AtomName[m]);
        strcpy(hb_atom2[num_hbonds], AtomName[n]);
        hb_dist[num_hbonds] = dd;
      }
    }
  }
  *nh = num_hbonds;
}


x86 assembly (clang, -O0):
<base_base_dist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
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)
movsd  %xmm0,-0x38(%rbp)
movq   $0x0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1b12 <base_base_dist+0x9c2>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe2f(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1242 <base_base_dist+0xf2>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe13(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1242 <base_base_dist+0xf2>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdf7(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1242 <base_base_dist+0xf2>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xddb(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    1247 <base_base_dist+0xf7>
jmp    1b01 <base_base_dist+0x9b1>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    1279 <base_base_dist+0x129>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1292 <base_base_dist+0x142>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x50,%eax
jne    1297 <base_base_dist+0x147>
jmp    1b01 <base_base_dist+0x9b1>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
je     12d1 <base_base_dist+0x181>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x49,%eax
jne    133e <base_base_dist+0x1ee>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd30(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1334 <base_base_dist+0x1e4>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd14(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1334 <base_base_dist+0x1e4>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcf8(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    1339 <base_base_dist+0x1e9>
jmp    1b01 <base_base_dist+0x9b1>
jmp    1504 <base_base_dist+0x3b4>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    13e9 <base_base_dist+0x299>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xca6(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     13df <base_base_dist+0x28f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc8a(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     13df <base_base_dist+0x28f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc6e(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     13df <base_base_dist+0x28f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc52(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    13e4 <base_base_dist+0x294>
jmp    1b01 <base_base_dist+0x9b1>
jmp    14ff <base_base_dist+0x3af>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x50,%eax
jne    1452 <base_base_dist+0x302>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbfb(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1448 <base_base_dist+0x2f8>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xbdf(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    144d <base_base_dist+0x2fd>
jmp    1b01 <base_base_dist+0x9b1>
jmp    14fa <base_base_dist+0x3aa>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     14a9 <base_base_dist+0x359>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
je     14a9 <base_base_dist+0x359>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
jne    14f5 <base_base_dist+0x3a5>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb58(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     14eb <base_base_dist+0x39b>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb46(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    14f0 <base_base_dist+0x3a0>
jmp    1b01 <base_base_dist+0x9b1>
jmp    14f5 <base_base_dist+0x3a5>
jmp    14fa <base_base_dist+0x3aa>
jmp    14ff <base_base_dist+0x3af>
jmp    1504 <base_base_dist+0x3b4>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1afc <base_base_dist+0x9ac>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xabb(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     15b6 <base_base_dist+0x466>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa9f(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     15b6 <base_base_dist+0x466>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa83(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     15b6 <base_base_dist+0x466>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa67(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    15bb <base_base_dist+0x46b>
jmp    1aeb <base_base_dist+0x99b>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    15ed <base_base_dist+0x49d>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1606 <base_base_dist+0x4b6>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x50,%eax
jne    160b <base_base_dist+0x4bb>
jmp    1aeb <base_base_dist+0x99b>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
je     1645 <base_base_dist+0x4f5>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x49,%eax
jne    16b2 <base_base_dist+0x562>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9bc(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     16a8 <base_base_dist+0x558>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x9a0(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     16a8 <base_base_dist+0x558>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x984(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    16ad <base_base_dist+0x55d>
jmp    1aeb <base_base_dist+0x99b>
jmp    1878 <base_base_dist+0x728>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    175d <base_base_dist+0x60d>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x932(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1753 <base_base_dist+0x603>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x916(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1753 <base_base_dist+0x603>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8fa(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1753 <base_base_dist+0x603>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8de(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    1758 <base_base_dist+0x608>
jmp    1aeb <base_base_dist+0x99b>
jmp    1873 <base_base_dist+0x723>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x50,%eax
jne    17c6 <base_base_dist+0x676>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x887(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     17bc <base_base_dist+0x66c>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x86b(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    17c1 <base_base_dist+0x671>
jmp    1aeb <base_base_dist+0x99b>
jmp    186e <base_base_dist+0x71e>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     181d <base_base_dist+0x6cd>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
je     181d <base_base_dist+0x6cd>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
jne    1869 <base_base_dist+0x719>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x7e4(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     185f <base_base_dist+0x70f>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x7d2(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    1864 <base_base_dist+0x714>
jmp    1aeb <base_base_dist+0x99b>
jmp    1869 <base_base_dist+0x719>
jmp    186e <base_base_dist+0x71e>
jmp    1873 <base_base_dist+0x723>
jmp    1878 <base_base_dist+0x728>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    18af <base_base_dist+0x75f>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    18af <base_base_dist+0x75f>
jmp    1aeb <base_base_dist+0x99b>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x73e(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1954 <base_base_dist+0x804>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x745(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1954 <base_base_dist+0x804>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x706(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1954 <base_base_dist+0x804>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6ea(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     1954 <base_base_dist+0x804>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6bf(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    19fe <base_base_dist+0x8ae>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x699(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     19f9 <base_base_dist+0x8a9>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x6a0(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     19f9 <base_base_dist+0x8a9>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x661(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     19f9 <base_base_dist+0x8a9>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x645(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
je     19f9 <base_base_dist+0x8a9>
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x61a(%rip),%rsi
call   1060 <strcmp@plt>
cmp    $0x0,%eax
jne    19fe <base_base_dist+0x8ae>
jmp    1aeb <base_base_dist+0x99b>
movq   $0x1,-0x68(%rbp)
cmpq   $0x3,-0x68(%rbp)
jg     1a56 <base_base_dist+0x906>
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movsd  %xmm0,-0x60(%rbp,%rax,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1a06 <base_base_dist+0x8b6>
lea    -0x60(%rbp),%rdi
call   1070 <veclen@plt>
movaps %xmm0,%xmm1
movsd  %xmm1,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ae6 <base_base_dist+0x996>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
cmp    $0x200,%rax
jle    1a9a <base_base_dist+0x94a>
lea    0x598(%rip),%rdi
call   1050 <nrerror@plt>
mov    0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
movsd  -0x40(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1aeb <base_base_dist+0x99b>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1518 <base_base_dist+0x3c8>
jmp    1b01 <base_base_dist+0x9b1>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    11a4 <base_base_dist+0x54>
mov    -0x80(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<base_base_dist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    (%rdx,%rdi,8),%rax
mov    0x8(%rax),%r14
cmp    0x10(%rax),%r14
jle    1192 <base_base_dist+0x42>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    0xa0(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    %rcx,(%rax)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,%r13
mov    %rdx,%r12
mov    %rdi,%rbp
mov    %rsi,0x10(%rsp)
mov    %r8,0x20(%rsp)
mov    %r9,0x30(%rsp)
movsd  %xmm0,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %rdi,0x8(%rsp)
jmp    11e1 <base_base_dist+0x91>
mov    0x8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r14),%rax
mov    (%r12,%rbp,8),%rcx
cmp    0x10(%rcx),%r14
mov    %rax,%r14
jge    1173 <base_base_dist+0x23>
mov    0x0(%r13,%r14,8),%r15
mov    %r15,%rdi
lea    0xe10(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11d0 <base_base_dist+0x80>
mov    %r15,%rdi
lea    0xe02(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11d0 <base_base_dist+0x80>
mov    %r15,%rdi
lea    0xdf4(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11d0 <base_base_dist+0x80>
mov    %r15,%rdi
lea    0xde6(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11d0 <base_base_dist+0x80>
mov    0x1(%r15),%al
cmp    $0x50,%al
je     11d0 <base_base_dist+0x80>
cmp    $0x43,%al
jne    1245 <base_base_dist+0xf5>
cmpb   $0x27,0x3(%r15)
je     11d0 <base_base_dist+0x80>
mov    0x20(%rsp),%rbx
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x41,%al
je     1268 <base_base_dist+0x118>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x49,%al
jne    1691 <base_base_dist+0x541>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0xd9d(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0xd8b(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0xd79(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
mov    0x8(%rsp),%rbp
je     11d0 <base_base_dist+0x80>
mov    0x10(%rsp),%rax
mov    (%r12,%rax,8),%rax
mov    0x8(%rax),%rbx
cmp    0x10(%rax),%rbx
jg     11d0 <base_base_dist+0x80>
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xd11(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xcff(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xced(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xcdb(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
movzbl 0x1(%rbp),%eax
cmp    $0x50,%al
mov    0x10(%rsp),%rcx
je     1675 <base_base_dist+0x525>
cmp    $0x43,%al
jne    1360 <base_base_dist+0x210>
cmpb   $0x27,0x3(%rbp)
je     1675 <base_base_dist+0x525>
mov    0x20(%rsp),%rbp
movsbl 0x0(%rbp,%rcx,1),%edi
mov    %rcx,%r15
call   1040 <toupper@plt>
cmp    $0x41,%al
je     1389 <base_base_dist+0x239>
movsbl 0x0(%rbp,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x49,%al
jne    1589 <base_base_dist+0x439>
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xc7c(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xc6a(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xc58(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    0x0(%r13,%r14,8),%rbp
cmpb   $0x43,0x1(%rbp)
jne    13ed <base_base_dist+0x29d>
mov    0x8(%r13,%rbx,8),%rax
cmpb   $0x43,0x1(%rax)
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xc09(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     144c <base_base_dist+0x2fc>
mov    %rbp,%rdi
lea    0xc1e(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     144c <base_base_dist+0x2fc>
mov    %rbp,%rdi
lea    0xbed(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     144c <base_base_dist+0x2fc>
mov    %rbp,%rdi
lea    0xbdf(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     144c <base_base_dist+0x2fc>
mov    %rbp,%rdi
lea    0xbc2(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
jne    14c4 <base_base_dist+0x374>
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xba5(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xbb6(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xb81(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xb6f(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xb4e(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    0x30(%rsp),%rcx
mov    (%rcx,%r14,8),%rax
mov    0x8(%rcx,%rbx,8),%rcx
movupd 0x8(%rax),%xmm0
movupd 0x8(%rcx),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x48(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
lea    0x40(%rsp),%rdi
call   1070 <veclen@plt>
movapd %xmm0,%xmm1
movsd  0x38(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1670 <base_base_dist+0x520>
movsd  %xmm1,0x28(%rsp)
cmpq   $0x200,0x18(%rsp)
jl     1531 <base_base_dist+0x3e1>
lea    0xb01(%rip),%rdi
call   1050 <nrerror@plt>
mov    0x18(%rsp),%rbp
lea    0x1(%rbp),%r15
mov    0xa8(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rdi
mov    0x0(%r13,%r14,8),%rsi
call   1030 <strcpy@plt>
mov    0xb0(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rdi
mov    0x8(%r13,%rbx,8),%rsi
call   1030 <strcpy@plt>
mov    0xb8(%rsp),%rax
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x8(%rax,%rbp,8)
mov    %r15,%rbp
mov    %r15,0x18(%rsp)
jmp    1670 <base_base_dist+0x520>
movsbl 0x0(%rbp,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    15d7 <base_base_dist+0x487>
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xa6d(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xa5b(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xa49(%rip),%rsi
jmp    1655 <base_base_dist+0x505>
movsbl 0x0(%rbp,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x50,%al
jne    160d <base_base_dist+0x4bd>
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xa1f(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0xa11(%rip),%rsi
jmp    13c6 <base_base_dist+0x276>
movsbl 0x0(%rbp,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     1646 <base_base_dist+0x4f6>
mov    0x10(%rsp),%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
je     1646 <base_base_dist+0x4f6>
mov    0x10(%rsp),%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
jne    13d3 <base_base_dist+0x283>
mov    0x8(%r13,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0x9bf(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     1670 <base_base_dist+0x520>
mov    %rbp,%rdi
lea    0x9bb(%rip),%rsi
jmp    13c6 <base_base_dist+0x276>
nopl   (%rax)
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%rbp
mov    (%r12,%rcx,8),%rax
add    $0x1,%rbx
cmp    0x10(%rax),%rbx
jl     12e0 <base_base_dist+0x190>
jmp    11d0 <base_base_dist+0x80>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    16dd <base_base_dist+0x58d>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0x967(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0x955(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0x943(%rip),%rsi
jmp    174f <base_base_dist+0x5ff>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x50,%al
jne    1715 <base_base_dist+0x5c5>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0x91b(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0x909(%rip),%rsi
jmp    12a5 <base_base_dist+0x155>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     1740 <base_base_dist+0x5f0>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
je     1740 <base_base_dist+0x5f0>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
jne    12b7 <base_base_dist+0x167>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0x8c5(%rip),%rsi
call   1060 <strcmp@plt>
test   %eax,%eax
je     11be <base_base_dist+0x6e>
mov    %rbp,%rdi
lea    0x8bd(%rip),%rsi
jmp    12a5 <base_base_dist+0x155>

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

LLVM IR (-O2):
@.str = [5 x i8] c" O3'\00"
@.str.1 = [5 x i8] c" O2P\00"
@.str.2 = [5 x i8] c" O5'\00"
@.str.3 = [5 x i8] c" O1P\00"
@.str.4 = [5 x i8] c" C4 \00"
@.str.5 = [5 x i8] c" C5 \00"
@.str.6 = [5 x i8] c" C6 \00"
@.str.7 = [5 x i8] c" C2 \00"
@.str.8 = [5 x i8] c" O4'\00"
@.str.9 = [44 x i8] c"Too many possible H-bonds between two bases\00"
define void @base_base_dist(i64 %0, i64 %1, i64** nocapture %2, i8** nocapture %3, i8* nocapture %4, double** nocapture %5, double %6, i64* nocapture writeonly %7, i8** nocapture %8, i8** nocapture %9, double* nocapture writeonly %10) {
%12 = alloca [4 x double]
%13 = bitcast [4 x double]* %12 to i8*
%14 = getelementptr inbounds i64*, i64** %2, i64 %0
%15 = load i64*, i64** %14
%16 = getelementptr inbounds i64, i64* %15, i64 1
%17 = load i64, i64* %16
%18 = getelementptr inbounds i64, i64* %15, i64 2
%19 = load i64, i64* %18
%20 = icmp sgt i64 %17, %19
br i1 %20, label %302, label %21
21: ; preds = %11
%22 = getelementptr inbounds i8, i8* %4, i64 %0
%23 = getelementptr inbounds i64*, i64** %2, i64 %1
%24 = getelementptr inbounds i8, i8* %4, i64 %1
%25 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 0
%26 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 1
%27 = getelementptr inbounds [4 x double], [4 x double]* %12, i64 0, i64 3
%28 = bitcast double* %26 to <2 x double>*
br label %29
29: ; preds = %21, %295
%30 = phi i64 [ 0, %21 ], [ %296, %295 ]
%31 = phi i64 [ %17, %21 ], [ %297, %295 ]
%32 = getelementptr inbounds i8*, i8** %3, i64 %31
%33 = load i8*, i8** %32
%34 = call i32 @strcmp(i8* dereferenceable(1) %33, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%35 = icmp eq i32 %34, 0
br i1 %35, label %295, label %36
36: ; preds = %29
%37 = call i32 @strcmp(i8* dereferenceable(1) %33, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%38 = icmp eq i32 %37, 0
br i1 %38, label %295, label %39
39: ; preds = %36
%40 = call i32 @strcmp(i8* dereferenceable(1) %33, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%41 = icmp eq i32 %40, 0
br i1 %41, label %295, label %42
42: ; preds = %39
%43 = call i32 @strcmp(i8* dereferenceable(1) %33, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%44 = icmp eq i32 %43, 0
br i1 %44, label %295, label %45
45: ; preds = %42
%46 = getelementptr inbounds i8, i8* %33, i64 1
%47 = load i8, i8* %46
switch i8 %47, label %52 [
i8 67, label %48
i8 80, label %295
]
48: ; preds = %45
%49 = getelementptr inbounds i8, i8* %33, i64 3
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 39
br i1 %51, label %295, label %52
52: ; preds = %45, %48
%53 = load i8, i8* %22
%54 = call signext i8 @toupper(i8 signext %53)
%55 = icmp eq i8 %54, 65
br i1 %55, label %60, label %56
56: ; preds = %52
%57 = load i8, i8* %22
%58 = call signext i8 @toupper(i8 signext %57)
%59 = icmp eq i8 %58, 73
br i1 %59, label %60, label %70
60: ; preds = %56, %52
%61 = load i8*, i8** %32
%62 = call i32 @strcmp(i8* dereferenceable(1) %61, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%63 = icmp eq i32 %62, 0
br i1 %63, label %295, label %64
64: ; preds = %60
%65 = call i32 @strcmp(i8* dereferenceable(1) %61, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%66 = icmp eq i32 %65, 0
br i1 %66, label %295, label %67
67: ; preds = %64
%68 = call i32 @strcmp(i8* dereferenceable(1) %61, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%69 = icmp eq i32 %68, 0
br i1 %69, label %295, label %117
70: ; preds = %56
%71 = load i8, i8* %22
%72 = call signext i8 @toupper(i8 signext %71)
%73 = icmp eq i8 %72, 71
br i1 %73, label %74, label %87
74: ; preds = %70
%75 = load i8*, i8** %32
%76 = call i32 @strcmp(i8* dereferenceable(1) %75, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%77 = icmp eq i32 %76, 0
br i1 %77, label %295, label %78
78: ; preds = %74
%79 = call i32 @strcmp(i8* dereferenceable(1) %75, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%80 = icmp eq i32 %79, 0
br i1 %80, label %295, label %81
81: ; preds = %78
%82 = call i32 @strcmp(i8* dereferenceable(1) %75, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%83 = icmp eq i32 %82, 0
br i1 %83, label %295, label %84
84: ; preds = %81
%85 = call i32 @strcmp(i8* dereferenceable(1) %75, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%86 = icmp eq i32 %85, 0
br i1 %86, label %295, label %117
87: ; preds = %70
%88 = load i8, i8* %22
%89 = call signext i8 @toupper(i8 signext %88)
%90 = icmp eq i8 %89, 80
br i1 %90, label %91, label %98
91: ; preds = %87
%92 = load i8*, i8** %32
%93 = call i32 @strcmp(i8* dereferenceable(1) %92, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%94 = icmp eq i32 %93, 0
br i1 %94, label %295, label %95
95: ; preds = %91
%96 = call i32 @strcmp(i8* dereferenceable(1) %92, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%97 = icmp eq i32 %96, 0
br i1 %97, label %295, label %117
98: ; preds = %87
%99 = load i8, i8* %22
%100 = call signext i8 @toupper(i8 signext %99)
%101 = icmp eq i8 %100, 85
br i1 %101, label %110, label %102
102: ; preds = %98
%103 = load i8, i8* %22
%104 = call signext i8 @toupper(i8 signext %103)
%105 = icmp eq i8 %104, 67
br i1 %105, label %110, label %106
106: ; preds = %102
%107 = load i8, i8* %22
%108 = call signext i8 @toupper(i8 signext %107)
%109 = icmp eq i8 %108, 84
br i1 %109, label %110, label %117
110: ; preds = %106, %102, %98
%111 = load i8*, i8** %32
%112 = call i32 @strcmp(i8* dereferenceable(1) %111, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%113 = icmp eq i32 %112, 0
br i1 %113, label %295, label %114
114: ; preds = %110
%115 = call i32 @strcmp(i8* dereferenceable(1) %111, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%116 = icmp eq i32 %115, 0
br i1 %116, label %295, label %117
117: ; preds = %84, %106, %114, %95, %67
%118 = load i64*, i64** %23
%119 = getelementptr inbounds i64, i64* %118, i64 1
%120 = load i64, i64* %119
%121 = getelementptr inbounds i64, i64* %118, i64 2
%122 = load i64, i64* %121
%123 = icmp sgt i64 %120, %122
br i1 %123, label %295, label %124
124: ; preds = %117
%125 = getelementptr inbounds double*, double** %5, i64 %31
br label %126
126: ; preds = %124, %288
%127 = phi i64 [ %30, %124 ], [ %289, %288 ]
%128 = phi i64 [ %120, %124 ], [ %290, %288 ]
%129 = getelementptr inbounds i8*, i8** %3, i64 %128
%130 = load i8*, i8** %129
%131 = call i32 @strcmp(i8* dereferenceable(1) %130, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%132 = icmp eq i32 %131, 0
br i1 %132, label %288, label %133
133: ; preds = %126
%134 = call i32 @strcmp(i8* dereferenceable(1) %130, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%135 = icmp eq i32 %134, 0
br i1 %135, label %288, label %136
136: ; preds = %133
%137 = call i32 @strcmp(i8* dereferenceable(1) %130, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%138 = icmp eq i32 %137, 0
br i1 %138, label %288, label %139
139: ; preds = %136
%140 = call i32 @strcmp(i8* dereferenceable(1) %130, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%141 = icmp eq i32 %140, 0
br i1 %141, label %288, label %142
142: ; preds = %139
%143 = getelementptr inbounds i8, i8* %130, i64 1
%144 = load i8, i8* %143
switch i8 %144, label %149 [
i8 67, label %145
i8 80, label %288
]
145: ; preds = %142
%146 = getelementptr inbounds i8, i8* %130, i64 3
%147 = load i8, i8* %146
%148 = icmp eq i8 %147, 39
br i1 %148, label %288, label %149
149: ; preds = %142, %145
%150 = load i8, i8* %24
%151 = call signext i8 @toupper(i8 signext %150)
%152 = icmp eq i8 %151, 65
br i1 %152, label %157, label %153
153: ; preds = %149
%154 = load i8, i8* %24
%155 = call signext i8 @toupper(i8 signext %154)
%156 = icmp eq i8 %155, 73
br i1 %156, label %157, label %167
157: ; preds = %153, %149
%158 = load i8*, i8** %129
%159 = call i32 @strcmp(i8* dereferenceable(1) %158, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%160 = icmp eq i32 %159, 0
br i1 %160, label %288, label %161
161: ; preds = %157
%162 = call i32 @strcmp(i8* dereferenceable(1) %158, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%163 = icmp eq i32 %162, 0
br i1 %163, label %288, label %164
164: ; preds = %161
%165 = call i32 @strcmp(i8* dereferenceable(1) %158, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%166 = icmp eq i32 %165, 0
br i1 %166, label %288, label %214
167: ; preds = %153
%168 = load i8, i8* %24
%169 = call signext i8 @toupper(i8 signext %168)
%170 = icmp eq i8 %169, 71
br i1 %170, label %171, label %184
171: ; preds = %167
%172 = load i8*, i8** %129
%173 = call i32 @strcmp(i8* dereferenceable(1) %172, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%174 = icmp eq i32 %173, 0
br i1 %174, label %288, label %175
175: ; preds = %171
%176 = call i32 @strcmp(i8* dereferenceable(1) %172, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%177 = icmp eq i32 %176, 0
br i1 %177, label %288, label %178
178: ; preds = %175
%179 = call i32 @strcmp(i8* dereferenceable(1) %172, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%180 = icmp eq i32 %179, 0
br i1 %180, label %288, label %181
181: ; preds = %178
%182 = call i32 @strcmp(i8* dereferenceable(1) %172, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%183 = icmp eq i32 %182, 0
br i1 %183, label %288, label %214
184: ; preds = %167
%185 = load i8, i8* %24
%186 = call signext i8 @toupper(i8 signext %185)
%187 = icmp eq i8 %186, 80
br i1 %187, label %188, label %195
188: ; preds = %184
%189 = load i8*, i8** %129
%190 = call i32 @strcmp(i8* dereferenceable(1) %189, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%191 = icmp eq i32 %190, 0
br i1 %191, label %288, label %192
192: ; preds = %188
%193 = call i32 @strcmp(i8* dereferenceable(1) %189, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%194 = icmp eq i32 %193, 0
br i1 %194, label %288, label %214
195: ; preds = %184
%196 = load i8, i8* %24
%197 = call signext i8 @toupper(i8 signext %196)
%198 = icmp eq i8 %197, 85
br i1 %198, label %207, label %199
199: ; preds = %195
%200 = load i8, i8* %24
%201 = call signext i8 @toupper(i8 signext %200)
%202 = icmp eq i8 %201, 67
br i1 %202, label %207, label %203
203: ; preds = %199
%204 = load i8, i8* %24
%205 = call signext i8 @toupper(i8 signext %204)
%206 = icmp eq i8 %205, 84
br i1 %206, label %207, label %214
207: ; preds = %203, %199, %195
%208 = load i8*, i8** %129
%209 = call i32 @strcmp(i8* dereferenceable(1) %208, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%210 = icmp eq i32 %209, 0
br i1 %210, label %288, label %211
211: ; preds = %207
%212 = call i32 @strcmp(i8* dereferenceable(1) %208, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%213 = icmp eq i32 %212, 0
br i1 %213, label %288, label %214
214: ; preds = %181, %203, %211, %192, %164
%215 = load i8*, i8** %32
%216 = getelementptr inbounds i8, i8* %215, i64 1
%217 = load i8, i8* %216
%218 = icmp eq i8 %217, 67
br i1 %218, label %219, label %224
219: ; preds = %214
%220 = load i8*, i8** %129
%221 = getelementptr inbounds i8, i8* %220, i64 1
%222 = load i8, i8* %221
%223 = icmp eq i8 %222, 67
br i1 %223, label %288, label %224
224: ; preds = %219, %214
%225 = call i32 @strcmp(i8* dereferenceable(1) %215, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%226 = icmp eq i32 %225, 0
br i1 %226, label %239, label %227
227: ; preds = %224
%228 = call i32 @strcmp(i8* dereferenceable(1) %215, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%229 = icmp eq i32 %228, 0
br i1 %229, label %239, label %230
230: ; preds = %227
%231 = call i32 @strcmp(i8* dereferenceable(1) %215, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%232 = icmp eq i32 %231, 0
br i1 %232, label %239, label %233
233: ; preds = %230
%234 = call i32 @strcmp(i8* dereferenceable(1) %215, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%235 = icmp eq i32 %234, 0
br i1 %235, label %239, label %236
236: ; preds = %233
%237 = call i32 @strcmp(i8* dereferenceable(1) %215, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%238 = icmp eq i32 %237, 0
br i1 %238, label %239, label %255
239: ; preds = %236, %233, %230, %227, %224
%240 = load i8*, i8** %129
%241 = call i32 @strcmp(i8* dereferenceable(1) %240, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%242 = icmp eq i32 %241, 0
br i1 %242, label %288, label %243
243: ; preds = %239
%244 = call i32 @strcmp(i8* dereferenceable(1) %240, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%245 = icmp eq i32 %244, 0
br i1 %245, label %288, label %246
246: ; preds = %243
%247 = call i32 @strcmp(i8* dereferenceable(1) %240, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%248 = icmp eq i32 %247, 0
br i1 %248, label %288, label %249
249: ; preds = %246
%250 = call i32 @strcmp(i8* dereferenceable(1) %240, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%251 = icmp eq i32 %250, 0
br i1 %251, label %288, label %252
252: ; preds = %249
%253 = call i32 @strcmp(i8* dereferenceable(1) %240, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%254 = icmp eq i32 %253, 0
br i1 %254, label %288, label %255
255: ; preds = %252, %236
%256 = load double*, double** %125
%257 = getelementptr inbounds double*, double** %5, i64 %128
%258 = load double*, double** %257
%259 = getelementptr inbounds double, double* %256, i64 1
%260 = getelementptr inbounds double, double* %258, i64 1
%261 = bitcast double* %259 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = bitcast double* %260 to <2 x double>*
%264 = load <2 x double>, <2 x double>* %263
%265 = fsub <2 x double> %262, %264
store <2 x double> %265, <2 x double>* %28
%266 = getelementptr inbounds double, double* %256, i64 3
%267 = load double, double* %266
%268 = getelementptr inbounds double, double* %258, i64 3
%269 = load double, double* %268
%270 = fsub double %267, %269
store double %270, double* %27
%271 = call double @veclen(double* %25)
%272 = fcmp olt double %271, %6
br i1 %272, label %273, label %288
273: ; preds = %255
%274 = add nsw i64 %127, 1
%275 = icmp sgt i64 %127, 511
br i1 %275, label %276, label %278
276: ; preds = %273
%277 = call i32 @nrerror(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.9, i64 0, i64 0))
br label %278
278: ; preds = %276, %273
%279 = getelementptr inbounds i8*, i8** %8, i64 %274
%280 = load i8*, i8** %279
%281 = load i8*, i8** %32
%282 = call i32 @strcpy(i8* %280, i8* %281)
%283 = getelementptr inbounds i8*, i8** %9, i64 %274
%284 = load i8*, i8** %283
%285 = load i8*, i8** %129
%286 = call i32 @strcpy(i8* %284, i8* %285)
%287 = getelementptr inbounds double, double* %10, i64 %274
store double %271, double* %287
br label %288
288: ; preds = %142, %255, %278, %239, %243, %246, %249, %252, %219, %207, %211, %188, %192, %171, %175, %178, %181, %157, %161, %164, %145, %126, %133, %136, %139
%289 = phi i64 [ %127, %145 ], [ %127, %219 ], [ %274, %278 ], [ %127, %255 ], [ %127, %252 ], [ %127, %249 ], [ %127, %246 ], [ %127, %243 ], [ %127, %239 ], [ %127, %164 ], [ %127, %161 ], [ %127, %157 ], [ %127, %181 ], [ %127, %178 ], [ %127, %175 ], [ %127, %171 ], [ %127, %192 ], [ %127, %188 ], [ %127, %211 ], [ %127, %207 ], [ %127, %139 ], [ %127, %136 ], [ %127, %133 ], [ %127, %126 ], [ %127, %142 ]
%290 = add nsw i64 %128, 1
%291 = load i64*, i64** %23
%292 = getelementptr inbounds i64, i64* %291, i64 2
%293 = load i64, i64* %292
%294 = icmp slt i64 %128, %293
br i1 %294, label %126, label %295
295: ; preds = %288, %117, %45, %110, %114, %91, %95, %74, %78, %81, %84, %60, %64, %67, %48, %29, %36, %39, %42
%296 = phi i64 [ %30, %48 ], [ %30, %67 ], [ %30, %64 ], [ %30, %60 ], [ %30, %84 ], [ %30, %81 ], [ %30, %78 ], [ %30, %74 ], [ %30, %95 ], [ %30, %91 ], [ %30, %114 ], [ %30, %110 ], [ %30, %42 ], [ %30, %39 ], [ %30, %36 ], [ %30, %29 ], [ %30, %45 ], [ %30, %117 ], [ %289, %288 ]
%297 = add nsw i64 %31, 1
%298 = load i64*, i64** %14
%299 = getelementptr inbounds i64, i64* %298, i64 2
%300 = load i64, i64* %299
%301 = icmp slt i64 %31, %300
br i1 %301, label %29, label %302
302: ; preds = %295, %11
%303 = phi i64 [ 0, %11 ], [ %296, %295 ]
store i64 %303, i64* %7
ret void
}