#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*/ H_catalog(long, long, char *, char **, long *, long *);
int /*<<< orphan*/ nrerror(char *);
scalar_t__ strchr(char *, char);
int /*<<< orphan*/ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
char toupper(char);
double veclen(double *);
void Hbond_pair(long i, long j, long **seidx, char **AtomName, char *bseq,
                double **xyz, double change, long *nh, char **hb_atom1,
                char **hb_atom2, double *hb_dist, long c_key, long bone_key) {
  double dd, dist, dtmp[4];
  long k, m, n, num_hbonds = 0;
  long without_H_m, with_H_m, without_H_n, with_H_n;
  for (m = seidx[i][1]; m <= seidx[i][2]; m++) {
    if (c_key == 0) {
      if (AtomName[m][1] == 'C')
        continue;
    }
    if (bone_key == 0) {
      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;
    }
    H_catalog(i, m, bseq, AtomName, &without_H_m, &with_H_m);
    for (n = seidx[j][1]; n <= seidx[j][2]; n++) {
      if (c_key == 0) {
        if (AtomName[n][1] == 'C')
          continue;
      }
      if (bone_key == 0) {
        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;
      H_catalog(j, n, bseq, AtomName, &without_H_n, &with_H_n);
      if (without_H_m == 1 && without_H_n == 1)
        continue;
      if ((strchr("NO", AtomName[m][1]) && AtomName[m][3] != '\'' &&
           AtomName[m][3] != 'P') &&
          (strchr("NO", AtomName[n][1]) && AtomName[n][3] != '\'' &&
           AtomName[n][3] != 'P')) {
        dist = 3.4 + change;
        if (dist >= 4)
          dist = 4.0;
      } else if ((AtomName[m][1] == 'C' &&
                  (AtomName[n][3] != '\'' && AtomName[n][3] != 'P' &&
                   strchr("NO", AtomName[n][1]))) ||
                 (AtomName[n][1] == 'C' &&
                  (AtomName[m][3] != '\'' && AtomName[m][3] != 'P' &&
                   strchr("NO", AtomName[m][1])))) {
        dist = 3.6 + change;
        if (dist >= 4.0)
          dist = 4.0;
      } else if ((AtomName[m][1] == 'O' && AtomName[m][3] == '\'' &&
                  strchr("NO", AtomName[n][1]) && AtomName[n][3] != '\'' &&
                  AtomName[n][3] != 'P') ||
                 (AtomName[n][1] == 'O' && AtomName[n][3] == '\'' &&
                  strchr("NO", AtomName[m][1]) && AtomName[m][3] != '\'' &&
                  AtomName[m][3] != 'P')) {
        dist = 3.4 + change;
        if (dist >= 4.0)
          dist = 4.0;
      } else if ((AtomName[m][3] == 'P' && AtomName[n][3] != '\'' &&
                  AtomName[n][1] != 'C') ||
                 (AtomName[n][3] == 'P' && AtomName[m][3] != '\'' &&
                  AtomName[m][1] != 'C')) {
        dist = 3.2 + change;
        if (dist >= 4.0)
          dist = 4.0;
      } else {
        dist = 3.1 + change;
        if (dist >= 3.8)
          dist = 3.8;
      }
      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):
<Hbond_pair>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
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,-0x90(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     212e <Hbond_pair+0xfbe>
cmpq   $0x0,0x30(%rbp)
jne    1217 <Hbond_pair+0xa7>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    1212 <Hbond_pair+0xa2>
jmp    211d <Hbond_pair+0xfad>
jmp    1217 <Hbond_pair+0xa7>
cmpq   $0x0,0x38(%rbp)
jne    12b0 <Hbond_pair+0x140>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1dfb(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     12a6 <Hbond_pair+0x136>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1ddf(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     12a6 <Hbond_pair+0x136>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1dc3(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     12a6 <Hbond_pair+0x136>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1da7(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    12ab <Hbond_pair+0x13b>
jmp    211d <Hbond_pair+0xfad>
jmp    12b0 <Hbond_pair+0x140>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    12e2 <Hbond_pair+0x172>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     12fb <Hbond_pair+0x18b>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x50,%eax
jne    1300 <Hbond_pair+0x190>
jmp    211d <Hbond_pair+0xfad>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
je     133a <Hbond_pair+0x1ca>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x49,%eax
jne    13a7 <Hbond_pair+0x237>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cf7(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     139d <Hbond_pair+0x22d>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cdb(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     139d <Hbond_pair+0x22d>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1cbf(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    13a2 <Hbond_pair+0x232>
jmp    211d <Hbond_pair+0xfad>
jmp    156d <Hbond_pair+0x3fd>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    1452 <Hbond_pair+0x2e2>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c6d(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1448 <Hbond_pair+0x2d8>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c51(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1448 <Hbond_pair+0x2d8>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c35(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1448 <Hbond_pair+0x2d8>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1c19(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    144d <Hbond_pair+0x2dd>
jmp    211d <Hbond_pair+0xfad>
jmp    1568 <Hbond_pair+0x3f8>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x50,%eax
jne    14bb <Hbond_pair+0x34b>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1bc2(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     14b1 <Hbond_pair+0x341>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1ba6(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    14b6 <Hbond_pair+0x346>
jmp    211d <Hbond_pair+0xfad>
jmp    1563 <Hbond_pair+0x3f3>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     1512 <Hbond_pair+0x3a2>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
je     1512 <Hbond_pair+0x3a2>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
jne    155e <Hbond_pair+0x3ee>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b1f(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1554 <Hbond_pair+0x3e4>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1b0d(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1559 <Hbond_pair+0x3e9>
jmp    211d <Hbond_pair+0xfad>
jmp    155e <Hbond_pair+0x3ee>
jmp    1563 <Hbond_pair+0x3f3>
jmp    1568 <Hbond_pair+0x3f8>
jmp    156d <Hbond_pair+0x3fd>
mov    -0x8(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rcx
lea    -0x98(%rbp),%r8
lea    -0xa0(%rbp),%r9
call   1080 <H_catalog@plt>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     2118 <Hbond_pair+0xfa8>
cmpq   $0x0,0x30(%rbp)
jne    15f5 <Hbond_pair+0x485>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    15f0 <Hbond_pair+0x480>
jmp    2101 <Hbond_pair+0xf91>
jmp    15f5 <Hbond_pair+0x485>
cmpq   $0x0,0x38(%rbp)
jne    169a <Hbond_pair+0x52a>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1a1a(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1690 <Hbond_pair+0x520>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19fb(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1690 <Hbond_pair+0x520>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19dc(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1690 <Hbond_pair+0x520>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x19bd(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1695 <Hbond_pair+0x525>
jmp    2101 <Hbond_pair+0xf91>
jmp    169a <Hbond_pair+0x52a>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    16d2 <Hbond_pair+0x562>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     16ee <Hbond_pair+0x57e>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x50,%eax
jne    16f3 <Hbond_pair+0x583>
jmp    2101 <Hbond_pair+0xf91>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
je     172d <Hbond_pair+0x5bd>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x49,%eax
jne    17a3 <Hbond_pair+0x633>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1901(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1799 <Hbond_pair+0x629>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x18e2(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1799 <Hbond_pair+0x629>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x18c3(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    179e <Hbond_pair+0x62e>
jmp    2101 <Hbond_pair+0xf91>
jmp    1981 <Hbond_pair+0x811>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    185a <Hbond_pair+0x6ea>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x186e(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1850 <Hbond_pair+0x6e0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x184f(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1850 <Hbond_pair+0x6e0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1830(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1850 <Hbond_pair+0x6e0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1811(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1855 <Hbond_pair+0x6e5>
jmp    2101 <Hbond_pair+0xf91>
jmp    197c <Hbond_pair+0x80c>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x50,%eax
jne    18c9 <Hbond_pair+0x759>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x17b7(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     18bf <Hbond_pair+0x74f>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1798(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    18c4 <Hbond_pair+0x754>
jmp    2101 <Hbond_pair+0xf91>
jmp    1977 <Hbond_pair+0x807>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     1920 <Hbond_pair+0x7b0>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
je     1920 <Hbond_pair+0x7b0>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
jne    1972 <Hbond_pair+0x802>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x170e(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1968 <Hbond_pair+0x7f8>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x16f9(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    196d <Hbond_pair+0x7fd>
jmp    2101 <Hbond_pair+0xf91>
jmp    1972 <Hbond_pair+0x802>
jmp    1977 <Hbond_pair+0x807>
jmp    197c <Hbond_pair+0x80c>
jmp    1981 <Hbond_pair+0x811>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    19bb <Hbond_pair+0x84b>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    19bb <Hbond_pair+0x84b>
jmp    2101 <Hbond_pair+0xf91>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1662(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1a60 <Hbond_pair+0x8f0>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1669(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1a60 <Hbond_pair+0x8f0>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x162a(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1a60 <Hbond_pair+0x8f0>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x160e(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1a60 <Hbond_pair+0x8f0>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x15e3(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1b19 <Hbond_pair+0x9a9>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x15ba(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1b14 <Hbond_pair+0x9a4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x15be(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1b14 <Hbond_pair+0x9a4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x157c(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1b14 <Hbond_pair+0x9a4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x155d(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
je     1b14 <Hbond_pair+0x9a4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x152f(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1b19 <Hbond_pair+0x9a9>
jmp    2101 <Hbond_pair+0xf91>
mov    -0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rcx
lea    -0xa8(%rbp),%r8
lea    -0xb0(%rbp),%r9
call   1080 <H_catalog@plt>
cmpq   $0x1,-0x98(%rbp)
01
jne    1b60 <Hbond_pair+0x9f0>
cmpq   $0x1,-0xa8(%rbp)
01
jne    1b60 <Hbond_pair+0x9f0>
jmp    2101 <Hbond_pair+0xf91>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x14ea(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
je     1c54 <Hbond_pair+0xae4>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1c54 <Hbond_pair+0xae4>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     1c54 <Hbond_pair+0xae4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x148f(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
je     1c54 <Hbond_pair+0xae4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1c54 <Hbond_pair+0xae4>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     1c54 <Hbond_pair+0xae4>
movsd  0x13ff(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x13d8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1c4f <Hbond_pair+0xadf>
movsd  0x13c6(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1fff <Hbond_pair+0xe8f>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    1cce <Hbond_pair+0xb5e>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1cce <Hbond_pair+0xb5e>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     1cce <Hbond_pair+0xb5e>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x13a2(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
jne    1d42 <Hbond_pair+0xbd2>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    1d7d <Hbond_pair+0xc0d>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1d7d <Hbond_pair+0xc0d>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     1d7d <Hbond_pair+0xc0d>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x132e(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
je     1d7d <Hbond_pair+0xc0d>
movsd  0x12de(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x12af(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1d78 <Hbond_pair+0xc08>
movsd  0x129d(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1ffa <Hbond_pair+0xe8a>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x4f,%eax
jne    1e10 <Hbond_pair+0xca0>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
jne    1e10 <Hbond_pair+0xca0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x1298(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
je     1e10 <Hbond_pair+0xca0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1e10 <Hbond_pair+0xca0>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
jne    1ea0 <Hbond_pair+0xd30>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x4f,%eax
jne    1edb <Hbond_pair+0xd6b>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
jne    1edb <Hbond_pair+0xd6b>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x1202(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1060 <strchr@plt>
cmp    $0x0,%rax
je     1edb <Hbond_pair+0xd6b>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1edb <Hbond_pair+0xd6b>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     1edb <Hbond_pair+0xd6b>
movsd  0x1178(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x1151(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1ed6 <Hbond_pair+0xd66>
movsd  0x113f(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1ff5 <Hbond_pair+0xe85>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
jne    1f2c <Hbond_pair+0xdbc>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1f2c <Hbond_pair+0xdbc>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    1f7a <Hbond_pair+0xe0a>
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
jne    1fb5 <Hbond_pair+0xe45>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     1fb5 <Hbond_pair+0xe45>
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
je     1fb5 <Hbond_pair+0xe45>
movsd  0x1096(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x1077(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1fb0 <Hbond_pair+0xe40>
movsd  0x1065(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1ff0 <Hbond_pair+0xe80>
movsd  0x104b(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0x102c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1feb <Hbond_pair+0xe7b>
movsd  0x101a(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1ff0 <Hbond_pair+0xe80>
jmp    1ff5 <Hbond_pair+0xe85>
jmp    1ffa <Hbond_pair+0xe8a>
jmp    1fff <Hbond_pair+0xe8f>
movq   $0x1,-0x78(%rbp)
cmpq   $0x3,-0x78(%rbp)
jg     205a <Hbond_pair+0xeea>
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x78(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    2007 <Hbond_pair+0xe97>
lea    -0x70(%rbp),%rdi
call   1090 <veclen@plt>
movaps %xmm0,%xmm1
movsd  %xmm1,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    20fc <Hbond_pair+0xf8c>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
cmp    $0x200,%rax
jle    20a4 <Hbond_pair+0xf34>
lea    0xfc1(%rip),%rdi
call   1050 <nrerror@plt>
mov    0x18(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    0x20(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
movsd  -0x40(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2101 <Hbond_pair+0xf91>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    15a7 <Hbond_pair+0x437>
jmp    211d <Hbond_pair+0xfad>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    11cf <Hbond_pair+0x5f>
mov    -0x90(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Hbond_pair>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    (%rdx,%rdi,8),%rax
mov    0x8(%rax),%r14
cmp    0x10(%rax),%r14
jle    11b8 <Hbond_pair+0x48>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    0xd0(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    %rcx,(%rax)
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rbx
mov    %rcx,%r13
mov    %rdx,%r12
mov    %r9,0x10(%rsp)
movsd  0xe32(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
movsd  0xe28(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0xe1e(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
addsd  0xe14(%rip),%xmm0
movsd  %xmm0,0x48(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r8,0x8(%rsp)
mov    %rsi,(%rsp)
mov    %rdi,0x30(%rsp)
jmp    124f <Hbond_pair+0xdf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r14),%rax
mov    0x30(%rsp),%rcx
mov    (%r12,%rcx,8),%rcx
cmp    0x10(%rcx),%r14
mov    %rax,%r14
mov    0x8(%rsp),%rbx
jge    1196 <Hbond_pair+0x26>
cmpq   $0x0,0xf0(%rsp)
jne    1265 <Hbond_pair+0xf5>
mov    0x0(%r13,%r14,8),%rax
cmpb   $0x43,0x1(%rax)
je     1230 <Hbond_pair+0xc0>
mov    0x0(%r13,%r14,8),%rbp
cmpq   $0x0,0xf8(%rsp)
je     1330 <Hbond_pair+0x1c0>
mov    0x1(%rbp),%al
cmp    $0x50,%al
je     1230 <Hbond_pair+0xc0>
cmp    $0x43,%al
jne    128a <Hbond_pair+0x11a>
cmpb   $0x27,0x3(%rbp)
je     1230 <Hbond_pair+0xc0>
mov    0x30(%rsp),%r15
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x41,%al
je     12af <Hbond_pair+0x13f>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x49,%al
jne    1396 <Hbond_pair+0x226>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0xd86(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xd74(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xd62(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
mov    %r13,%rcx
lea    0x58(%rsp),%r8
lea    0x68(%rsp),%r9
call   1080 <H_catalog@plt>
mov    (%rsp),%rdx
mov    (%r12,%rdx,8),%rax
mov    0x8(%rax),%r15
cmp    0x10(%rax),%r15
jle    14e9 <Hbond_pair+0x379>
jmp    1230 <Hbond_pair+0xc0>
nop
mov    %rbp,%rdi
lea    0xcf6(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xce4(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xcd2(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xcc0(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
mov    0x8(%rsp),%rbx
jne    1279 <Hbond_pair+0x109>
jmp    1230 <Hbond_pair+0xc0>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    13e3 <Hbond_pair+0x273>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0xc91(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xc7f(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xc6d(%rip),%rsi
jmp    1459 <Hbond_pair+0x2e9>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x50,%al
jne    141c <Hbond_pair+0x2ac>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0xc44(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xc32(%rip),%rsi
jmp    12ec <Hbond_pair+0x17c>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     144a <Hbond_pair+0x2da>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
je     144a <Hbond_pair+0x2da>
movsbl (%rbx,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
jne    12f9 <Hbond_pair+0x189>
mov    0x0(%r13,%r14,8),%rbp
mov    %rbp,%rdi
lea    0xbeb(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1230 <Hbond_pair+0xc0>
mov    %rbp,%rdi
lea    0xbe3(%rip),%rsi
jmp    12ec <Hbond_pair+0x17c>
mov    0x18(%rsp),%rbx
lea    0x1(%rbx),%rbp
mov    0xd8(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rdi
mov    0x0(%r13,%r14,8),%rsi
call   1030 <strcpy@plt>
mov    0xe0(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rdi
mov    0x0(%r13,%r15,8),%rsi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rax
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rax,%rbx,8)
mov    %rbp,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%rdx
lea    0x1(%r15),%rax
mov    (%r12,%rdx,8),%rcx
cmp    0x10(%rcx),%r15
mov    %rax,%r15
jge    1230 <Hbond_pair+0xc0>
cmpq   $0x0,0xf0(%rsp)
jne    14ff <Hbond_pair+0x38f>
mov    0x0(%r13,%r15,8),%rax
cmpb   $0x43,0x1(%rax)
je     14d4 <Hbond_pair+0x364>
mov    0x0(%r13,%r15,8),%rbp
cmpq   $0x0,0xf8(%rsp)
je     17a0 <Hbond_pair+0x630>
movzbl 0x1(%rbp),%eax
cmp    $0x50,%al
je     14d4 <Hbond_pair+0x364>
cmp    $0x43,%al
jne    1525 <Hbond_pair+0x3b5>
cmpb   $0x27,0x3(%rbp)
je     14d4 <Hbond_pair+0x364>
mov    0x8(%rsp),%rbx
movsbl (%rbx,%rdx,1),%edi
mov    %rdx,%rbp
call   1040 <toupper@plt>
cmp    $0x41,%al
je     154b <Hbond_pair+0x3db>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x49,%al
jne    1805 <Hbond_pair+0x695>
mov    0x0(%r13,%r15,8),%rbp
mov    %rbp,%rdi
lea    0xaea(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0xad8(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0xac6(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    0x0(%r13,%r14,8),%rbp
cmpb   $0x43,0x1(%rbp)
jne    15af <Hbond_pair+0x43f>
mov    0x0(%r13,%r15,8),%rax
cmpb   $0x43,0x1(%rax)
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0xa77(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     160e <Hbond_pair+0x49e>
mov    %rbp,%rdi
lea    0xa8c(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     160e <Hbond_pair+0x49e>
mov    %rbp,%rdi
lea    0xa5b(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     160e <Hbond_pair+0x49e>
mov    %rbp,%rdi
lea    0xa4d(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     160e <Hbond_pair+0x49e>
mov    %rbp,%rdi
lea    0xa30(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
jne    1686 <Hbond_pair+0x516>
mov    0x0(%r13,%r15,8),%rbp
mov    %rbp,%rdi
lea    0xa13(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0xa24(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x9ef(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x9dd(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x9bc(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    (%rsp),%rdi
mov    %r15,%rsi
mov    0x8(%rsp),%rdx
mov    %r13,%rcx
lea    0x50(%rsp),%r8
lea    0x60(%rsp),%r9
call   1080 <H_catalog@plt>
cmpq   $0x1,0x58(%rsp)
jne    16b8 <Hbond_pair+0x548>
cmpq   $0x1,0x50(%rsp)
je     14d0 <Hbond_pair+0x360>
mov    0x0(%r13,%r14,8),%rax
movsbl 0x1(%rax),%esi
lea    0x995(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
je     1712 <Hbond_pair+0x5a2>
mov    0x0(%r13,%r14,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x27,%al
je     1712 <Hbond_pair+0x5a2>
cmp    $0x50,%al
je     1712 <Hbond_pair+0x5a2>
mov    0x0(%r13,%r15,8),%rax
movsbl 0x1(%rax),%esi
lea    0x96a(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
je     1712 <Hbond_pair+0x5a2>
mov    0x0(%r13,%r15,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x27,%al
je     1712 <Hbond_pair+0x5a2>
cmp    $0x50,%al
jne    19c9 <Hbond_pair+0x859>
mov    0x0(%r13,%r14,8),%rax
cmpb   $0x43,0x1(%rax)
jne    1745 <Hbond_pair+0x5d5>
mov    0x0(%r13,%r15,8),%rax
movzbl 0x3(%rax),%ecx
cmp    $0x27,%cl
je     1745 <Hbond_pair+0x5d5>
cmp    $0x50,%cl
je     1745 <Hbond_pair+0x5d5>
movsbl 0x1(%rax),%esi
lea    0x922(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
jne    1788 <Hbond_pair+0x618>
mov    0x0(%r13,%r15,8),%rax
cmpb   $0x43,0x1(%rax)
jne    18f4 <Hbond_pair+0x784>
mov    0x0(%r13,%r14,8),%rax
movzbl 0x3(%rax),%ecx
cmp    $0x27,%cl
je     18f4 <Hbond_pair+0x784>
cmp    $0x50,%cl
je     18f4 <Hbond_pair+0x784>
movsbl 0x1(%rax),%esi
lea    0x8e3(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
je     18f4 <Hbond_pair+0x784>
movsd  0x38(%rsp),%xmm0
jmp    19cf <Hbond_pair+0x85f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rdi
lea    0x886(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x874(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x862(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x850(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
mov    (%rsp),%rdx
jne    1513 <Hbond_pair+0x3a3>
jmp    14d4 <Hbond_pair+0x364>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    1854 <Hbond_pair+0x6e4>
mov    0x0(%r13,%r15,8),%rbp
mov    %rbp,%rdi
lea    0x823(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x811(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x7ff(%rip),%rsi
jmp    18d8 <Hbond_pair+0x768>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x50,%al
jne    188c <Hbond_pair+0x71c>
mov    0x0(%r13,%r15,8),%rbp
mov    %rbp,%rdi
lea    0x7d4(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x7c2(%rip),%rsi
jmp    1588 <Hbond_pair+0x418>
movsbl (%rbx,%rbp,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     18c9 <Hbond_pair+0x759>
mov    0x8(%rsp),%rax
mov    (%rsp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
je     18c9 <Hbond_pair+0x759>
mov    0x8(%rsp),%rax
mov    (%rsp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
jne    1595 <Hbond_pair+0x425>
mov    0x0(%r13,%r15,8),%rbp
mov    %rbp,%rdi
lea    0x76c(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     14d0 <Hbond_pair+0x360>
mov    %rbp,%rdi
lea    0x764(%rip),%rsi
jmp    1588 <Hbond_pair+0x418>
mov    0x0(%r13,%r14,8),%rax
cmpb   $0x4f,0x1(%rax)
jne    1934 <Hbond_pair+0x7c4>
cmpb   $0x27,0x3(%rax)
jne    1934 <Hbond_pair+0x7c4>
mov    0x0(%r13,%r15,8),%rax
movsbl 0x1(%rax),%esi
lea    0x748(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
je     1934 <Hbond_pair+0x7c4>
mov    0x0(%r13,%r15,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x50,%al
je     1934 <Hbond_pair+0x7c4>
cmp    $0x27,%al
jne    19c9 <Hbond_pair+0x859>
mov    0x0(%r13,%r15,8),%rax
cmpb   $0x4f,0x1(%rax)
jne    1970 <Hbond_pair+0x800>
cmpb   $0x27,0x3(%rax)
jne    1970 <Hbond_pair+0x800>
mov    0x0(%r13,%r14,8),%rax
movsbl 0x1(%rax),%esi
lea    0x708(%rip),%rdi
call   1060 <strchr@plt>
test   %rax,%rax
je     1970 <Hbond_pair+0x800>
mov    0x0(%r13,%r14,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x27,%al
je     1970 <Hbond_pair+0x800>
cmp    $0x50,%al
jne    19c9 <Hbond_pair+0x859>
mov    0x0(%r13,%r14,8),%rax
movzbl 0x3(%rax),%ecx
mov    0x0(%r13,%r15,8),%rsi
movzbl 0x3(%rsi),%edx
cmp    $0x50,%cl
jne    1992 <Hbond_pair+0x822>
cmp    $0x27,%dl
je     19a2 <Hbond_pair+0x832>
cmpb   $0x43,0x1(%rsi)
jne    19c1 <Hbond_pair+0x851>
cmp    $0x50,%dl
jne    19a2 <Hbond_pair+0x832>
cmp    $0x27,%cl
je     19a2 <Hbond_pair+0x832>
cmpb   $0x43,0x1(%rax)
jne    19c1 <Hbond_pair+0x851>
movsd  0x48(%rsp),%xmm0
ucomisd 0x678(%rip),%xmm0
mov    0x10(%rsp),%rcx
jb     19e6 <Hbond_pair+0x876>
movsd  0x669(%rip),%xmm0
jmp    19e6 <Hbond_pair+0x876>
movsd  0x40(%rsp),%xmm0
jmp    19cf <Hbond_pair+0x85f>
movsd  0x28(%rsp),%xmm0
ucomisd 0x649(%rip),%xmm0
mov    0x10(%rsp),%rcx
jb     19e6 <Hbond_pair+0x876>
movsd  0x63a(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    (%rcx,%r14,8),%rax
mov    (%rcx,%r15,8),%rcx
movupd 0x8(%rax),%xmm0
movupd 0x8(%rcx),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x78(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x88(%rsp)
lea    0x70(%rsp),%rdi
call   1090 <veclen@plt>
movsd  0x20(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    14d0 <Hbond_pair+0x360>
movsd  %xmm0,0x20(%rsp)
cmpq   $0x200,0x18(%rsp)
jl     1475 <Hbond_pair+0x305>
lea    0x60f(%rip),%rdi
call   1050 <nrerror@plt>
jmp    1475 <Hbond_pair+0x305>

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