#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*/ base_stack(long, long, char *, long **, char **, double **,
                              double *, long *);
int /*<<< orphan*/ bpstep_par(double **, double *, double **, double *,
                              double *, double **, double *);
double **dmatrix(int, int, int, int);
double dot(double *, double *);
double dot2ang(double);
double fabs(double);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
scalar_t__ isdigit(char);
scalar_t__ num_strmatch(char *, char **, int, int);
int /*<<< orphan*/ sprintf(char *, char *, int, int, ...);
scalar_t__ strchr(char *, char);
scalar_t__ strcmp(char *, char *);
int toupper(char);
int /*<<< orphan*/ vec_norm(double *);
double veclen(double *);
void check_pair(long i, long j, char *bseq, long **seidx, double **xyz,
                double **Nxyz, double **orien, double **org, char **AtomName,
                double *BPRS, double *rtn_val, long *bpid, long network,
                char *criteria) {
  char bpi[3];
  long k, koffset, l, m, n, short_contact = 0, stack_key = 0;
  double pars[7], **r1, **r2, **mst;
  double dd, dir_x, dir_y, dorg[4], zave[4], dNN_vec[4], cc_dist = 0;
  static char *WC[9] = {"XX", "AT", "AU", "TA", "UA", "GC", "CG", "IC", "CI"};
  *bpid = 0;
  if (i == j)
    return;
  for (k = 1; k <= 3; k++) {
    dorg[k] = org[j][k] - org[i][k];
    dNN_vec[k] = Nxyz[j][k] - Nxyz[i][k];
  }
  rtn_val[1] = veclen(dorg);
  dir_x = dot(&orien[i][0], &orien[j][0]);
  dir_y = dot(&orien[i][3], &orien[j][3]);
  dd = dot(&orien[i][6], &orien[j][6]);
  if (dd <= 0.0)
    for (k = 1; k <= 3; k++)
      zave[k] = orien[i][6 + k] - orien[j][6 + k];
  else
    for (k = 1; k <= 3; k++)
      zave[k] = orien[i][6 + k] + orien[j][6 + k];
  vec_norm(zave);
  rtn_val[2] = fabs(dot(dorg, zave));
  if (rtn_val[2] > BPRS[3])
    return;
  rtn_val[3] = 90.0 - fabs(dot2ang(dd) - 90.0);
  if (rtn_val[3] > BPRS[4])
    return;
  if (rtn_val[3] <= 10 && rtn_val[2] >= 2.2)
    return;
  rtn_val[4] = veclen(dNN_vec);
  if (rtn_val[4] < BPRS[5])
    return;
  rtn_val[5] = rtn_val[1] + 2.0 * rtn_val[2];
  if (network) {
    if (rtn_val[2] <= BPRS[3] && rtn_val[3] <= BPRS[4] && rtn_val[4] >= BPRS[5])
      *bpid = 1;
    return;
  }
  if (rtn_val[4] <= 6 && rtn_val[2] >= 1.80)
    return;
  if (rtn_val[1] <= BPRS[2] && rtn_val[2] <= BPRS[3] && rtn_val[3] <= BPRS[4] &&
      rtn_val[4] >= BPRS[5]) {
    for (m = seidx[i][1]; m <= seidx[i][2] && !short_contact; m++) {
      if (strchr("P", AtomName[m][1]) || strchr("P", AtomName[m][3]))
        continue;
      if (AtomName[m][3] == '\'' && strcmp(AtomName[m], " O2'"))
        continue;
      for (n = seidx[j][1]; n <= seidx[j][2] && !short_contact; n++) {
        if (strchr("P", AtomName[n][1]) || strchr("P", AtomName[n][3]))
          continue;
        if (AtomName[n][3] == '\'' && strcmp(AtomName[n], " O2'"))
          continue;
        if (strchr("ON", AtomName[m][1]) && AtomName[m][0] == ' ' &&
            isdigit(AtomName[m][2]) && strchr("ON", AtomName[n][1]) &&
            AtomName[n][0] == ' ' && isdigit(AtomName[n][2])) {
          for (k = 1; k <= 3; k++)
            dorg[k] = xyz[n][k] - xyz[m][k];
          if (veclen(dorg) <= BPRS[1]) {
            short_contact = 1;
            break;
          }
        }
      }
      if (short_contact == 1)
        break;
    }
    if (short_contact) {
      r1 = dmatrix(1, 3, 1, 3);
      r2 = dmatrix(1, 3, 1, 3);
      mst = dmatrix(1, 3, 1, 3);
      base_stack(i, j, bseq, seidx, AtomName, xyz, rtn_val, &stack_key);
      if (stack_key > 0)
        return;
      sprintf(criteria, "%7.2f %7.2f %7.2f %7.2f %7.2f", cc_dist, rtn_val[1],
              rtn_val[2], rtn_val[3], rtn_val[4]);
      sprintf(bpi, "%c%c", toupper(bseq[i]), toupper(bseq[j]));
      *bpid = -1;
      k = dir_x > 0.0 && dir_y < 0.0 && dd < 0.0;
      if (k) {
        *bpid = 1;
        if (rtn_val[1] <= 2.5 && num_strmatch(bpi, WC, 1, 8))
          *bpid = 2;
      }
      if (*bpid == 2)
        rtn_val[5] -= 1.5;
      for (k = 1; k <= 3; k++) {
        rtn_val[k + 8] = orien[i][6 + k];
        rtn_val[k + 11] = orien[j][6 + k];
        koffset = (k - 1) * 3;
        for (l = 1; l <= 3; l++) {
          r1[l][k] = orien[i][koffset + l];
          r2[l][k] = (k == 1) ? orien[j][koffset + l] : -orien[j][koffset + l];
        }
      }
      bpstep_par(r2, org[j], r1, org[i], pars, mst, &rtn_val[5]);
      for (k = 1; k <= 6; k++)
        rtn_val[14 + k] = pars[k];
      free_dmatrix(r1, 1, 3, 1, 3);
      free_dmatrix(r2, 1, 3, 1, 3);
      free_dmatrix(mst, 1, 3, 1, 3);
    }
  }
}


x86 assembly (clang, -O0):
<check_pair>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
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)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    0x38(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    125c <check_pair+0x7c>
jmp    1e5c <check_pair+0xc7c>
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     12ee <check_pair+0x10e>
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x140(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1264 <check_pair+0x84>
lea    -0x100(%rbp),%rdi
call   10e0 <veclen@plt>
mov    0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1030 <dot@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
add    $0x18,%rdi
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
add    $0x18,%rsi
call   1030 <dot@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
add    $0x30,%rdi
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
add    $0x30,%rsi
call   1030 <dot@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
jb     13fb <check_pair+0x21b>
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     13f6 <check_pair+0x216>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    139b <check_pair+0x1bb>
jmp    1463 <check_pair+0x283>
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     145e <check_pair+0x27e>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1403 <check_pair+0x223>
jmp    1463 <check_pair+0x283>
lea    -0x120(%rbp),%rdi
call   10a0 <vec_norm@plt>
lea    -0x100(%rbp),%rdi
lea    -0x120(%rbp),%rsi
call   1030 <dot@plt>
movaps 0xb77(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd 0x18(%rax),%xmm0
jbe    14b3 <check_pair+0x2d3>
jmp    1e5c <check_pair+0xc7c>
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <dot2ang@plt>
movaps %xmm0,%xmm1
movsd  0xb45(%rip),%xmm0
subsd  %xmm0,%xmm1
movaps 0xb2a(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb2e(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    0x30(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd 0x20(%rax),%xmm0
jbe    150c <check_pair+0x32c>
jmp    1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0xb00(%rip),%xmm0
ucomisd 0x18(%rax),%xmm0
jb     1543 <check_pair+0x363>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xaec(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1543 <check_pair+0x363>
jmp    1e5c <check_pair+0xc7c>
lea    -0x140(%rbp),%rdi
call   10e0 <veclen@plt>
mov    0x30(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    0x30(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x28(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1579 <check_pair+0x399>
jmp    1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,0x28(%rax)
cmpq   $0x0,0x40(%rbp)
je     1607 <check_pair+0x427>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1602 <check_pair+0x422>
mov    0x30(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1602 <check_pair+0x422>
mov    0x30(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd 0x28(%rax),%xmm0
jb     1602 <check_pair+0x422>
mov    0x38(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0xa15(%rip),%xmm0
ucomisd 0x20(%rax),%xmm0
jb     163e <check_pair+0x45e>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xa01(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     163e <check_pair+0x45e>
jmp    1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1e5c <check_pair+0xc7c>
mov    0x30(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd 0x28(%rax),%xmm0
jb     1e5c <check_pair+0xc7c>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rdx
mov    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cmp    0x10(%rdx),%rcx
mov    %al,-0x149(%rbp)
jg     16f0 <check_pair+0x510>
cmpq   $0x0,-0x68(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x149(%rbp)
mov    -0x149(%rbp),%al
test   $0x1,%al
jne    1703 <check_pair+0x523>
jmp    1a03 <check_pair+0x823>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x94d(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
jne    174f <check_pair+0x56f>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x927(%rip),%rdi
movsbl 0x3(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     1754 <check_pair+0x574>
jmp    19f2 <check_pair+0x812>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
jne    1794 <check_pair+0x5b4>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x8e5(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%rax
je     1794 <check_pair+0x5b4>
jmp    19f2 <check_pair+0x812>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cmp    0x10(%rdx),%rcx
mov    %al,-0x14a(%rbp)
jg     17da <check_pair+0x5fa>
cmpq   $0x0,-0x68(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x14a(%rbp)
mov    -0x14a(%rbp),%al
test   $0x1,%al
jne    17ed <check_pair+0x60d>
jmp    19dd <check_pair+0x7fd>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x863(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
jne    1839 <check_pair+0x659>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x83d(%rip),%rdi
movsbl 0x3(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     183e <check_pair+0x65e>
jmp    19cc <check_pair+0x7ec>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
jne    187e <check_pair+0x69e>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x7fb(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%rax
je     187e <check_pair+0x69e>
jmp    19cc <check_pair+0x7ec>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x7d9(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     19c7 <check_pair+0x7e7>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    19c7 <check_pair+0x7e7>
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%rax
je     19c7 <check_pair+0x7e7>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x77c(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     19c7 <check_pair+0x7e7>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    19c7 <check_pair+0x7e7>
mov    0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%rax
je     19c7 <check_pair+0x7e7>
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     1993 <check_pair+0x7b3>
mov    -0x28(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x100(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1940 <check_pair+0x760>
lea    -0x100(%rbp),%rdi
call   10e0 <veclen@plt>
movaps %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     19c2 <check_pair+0x7e2>
movq   $0x1,-0x68(%rbp)
jmp    19dd <check_pair+0x7fd>
jmp    19c7 <check_pair+0x7e7>
jmp    19cc <check_pair+0x7ec>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    17a8 <check_pair+0x5c8>
cmpq   $0x1,-0x68(%rbp)
jne    19ed <check_pair+0x80d>
jmp    1a03 <check_pair+0x823>
jmp    19f2 <check_pair+0x812>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    16be <check_pair+0x4de>
cmpq   $0x0,-0x68(%rbp)
je     1e57 <check_pair+0xc77>
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <dmatrix@plt>
mov    %rax,-0xb8(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <dmatrix@plt>
mov    %rax,-0xc0(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10d0 <dmatrix@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    -0x28(%rbp),%r9
mov    0x30(%rbp),%r10
lea    -0x70(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1080 <base_stack@plt>
cmpq   $0x0,-0x70(%rbp)
jle    1a9a <check_pair+0x8ba>
jmp    1e5c <check_pair+0xc7c>
mov    0x48(%rbp),%rdi
cvttsd2si -0x148(%rbp),%edx
ff
mov    0x30(%rbp),%rax
cvttsd2si 0x8(%rax),%ecx
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x30(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    0x30(%rbp),%rax
movsd  0x20(%rax),%xmm2
lea    0x59c(%rip),%rsi
mov    $0x3,%al
call   1100 <sprintf@plt>
lea    -0x33(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <toupper@plt>
mov    %eax,-0x150(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <toupper@plt>
mov    -0x158(%rbp),%rdi
mov    -0x150(%rbp),%edx
mov    %eax,%ecx
lea    0x56a(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
mov    0x38(%rbp),%rax
movq   $0xffffffffffffffff,(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x14b(%rbp)
jbe    1b7d <check_pair+0x99d>
xor    %eax,%eax
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
mov    %al,-0x14b(%rbp)
jbe    1b7d <check_pair+0x99d>
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
seta   %al
mov    %al,-0x14b(%rbp)
mov    -0x14b(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1bef <check_pair+0xa0f>
mov    0x38(%rbp),%rax
movq   $0x1,(%rax)
mov    0x30(%rbp),%rax
movsd  0x488(%rip),%xmm0
ucomisd 0x8(%rax),%xmm0
jb     1bea <check_pair+0xa0a>
lea    -0x33(%rbp),%rdi
lea    0x24da(%rip),%rsi
mov    $0x1,%edx
mov    $0x8,%ecx
call   1060 <num_strmatch@plt>
cmp    $0x0,%rax
je     1bea <check_pair+0xa0a>
mov    0x38(%rbp),%rax
movq   $0x2,(%rax)
jmp    1bef <check_pair+0xa0f>
mov    0x38(%rbp),%rax
cmpq   $0x2,(%rax)
jne    1c17 <check_pair+0xa37>
mov    0x30(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  0x432(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     1d7c <check_pair+0xb9c>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x40(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,0x58(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
sub    $0x1,%rax
imul   $0x3,%rax,%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,-0x50(%rbp)
cmpq   $0x3,-0x50(%rbp)
jg     1d66 <check_pair+0xb86>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpq   $0x1,-0x40(%rbp)
jne    1cfd <check_pair+0xb1d>
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1d35 <check_pair+0xb55>
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1c90 <check_pair+0xab0>
jmp    1d6b <check_pair+0xb8b>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1c1f <check_pair+0xa3f>
mov    -0xc0(%rbp),%rdi
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0xb8(%rbp),%rdx
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    -0xb0(%rbp),%r8
mov    -0xc8(%rbp),%r9
mov    0x30(%rbp),%rax
add    $0x28,%rax
mov    %rax,(%rsp)
call   10b0 <bpstep_par@plt>
movq   $0x1,-0x40(%rbp)
cmpq   $0x6,-0x40(%rbp)
jg     1e03 <check_pair+0xc23>
mov    -0x40(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
mov    0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0xe,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1dc9 <check_pair+0xbe9>
mov    -0xb8(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
mov    -0xc0(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
mov    -0xc8(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
jmp    1e5c <check_pair+0xc7c>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_pair>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rdx,0x20(%rsp)
mov    0x148(%rsp),%rax
movq   $0x0,0x28(%rsp)
movq   $0x0,(%rax)
cmp    %rsi,%rdi
je     14dc <check_pair+0x2fc>
mov    %r8,%r12
mov    %rcx,%r13
mov    %rsi,%rbx
mov    %rdi,%r14
mov    0x140(%rsp),%rbp
mov    0x128(%rsp),%rcx
mov    0x120(%rsp),%r15
mov    (%rcx,%rsi,8),%rax
mov    (%rcx,%rdi,8),%rcx
mov    (%r9,%rsi,8),%rdx
mov    (%r9,%rdi,8),%rsi
movsd  0x8(%rax),%xmm0
subsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x10(%rax),%xmm0
subsd  0x10(%rcx),%xmm0
movsd  0x8(%rdx),%xmm1
movsd  0x8(%rsi),%xmm2
movsd  %xmm0,0x40(%rsp)
movhpd 0x10(%rdx),%xmm1
movhpd 0x10(%rsi),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm1,0x98(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x18(%rdx),%xmm0
subsd  0x18(%rsi),%xmm0
movsd  %xmm0,0xa8(%rsp)
lea    0x30(%rsp),%rdi
call   10e0 <veclen@plt>
movsd  %xmm0,0x8(%rbp)
mov    (%r15,%r14,8),%rdi
mov    (%r15,%rbx,8),%rsi
call   1030 <dot@plt>
movsd  %xmm0,0x68(%rsp)
mov    (%r15,%r14,8),%rdi
add    $0x18,%rdi
mov    (%r15,%rbx,8),%rsi
add    $0x18,%rsi
call   1030 <dot@plt>
movsd  %xmm0,0x60(%rsp)
mov    (%r15,%r14,8),%rdi
add    $0x30,%rdi
mov    (%r15,%rbx,8),%rsi
add    $0x30,%rsi
call   1030 <dot@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x18(%rsp)
ucomisd %xmm0,%xmm1
mov    (%r15,%r14,8),%rcx
mov    (%r15,%rbx,8),%rax
movsd  0x38(%rcx),%xmm0
movsd  0x38(%rax),%xmm1
jae    1343 <check_pair+0x163>
movhpd 0x40(%rcx),%xmm0
movhpd 0x40(%rax),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x78(%rsp)
movsd  0x48(%rcx),%xmm0
addsd  0x48(%rax),%xmm0
jmp    1361 <check_pair+0x181>
movhpd 0x40(%rcx),%xmm0
movhpd 0x40(%rax),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x78(%rsp)
movsd  0x48(%rcx),%xmm0
subsd  0x48(%rax),%xmm0
movsd  %xmm0,0x88(%rsp)
lea    0x70(%rsp),%rbp
mov    %rbp,%rdi
call   10a0 <vec_norm@plt>
lea    0x30(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <dot@plt>
andpd  0xc74(%rip),%xmm0
mov    0x140(%rsp),%rbp
movlpd %xmm0,0x10(%rbp)
mov    0x138(%rsp),%rax
ucomisd 0x18(%rax),%xmm0
ja     14dc <check_pair+0x2fc>
movsd  0x18(%rsp),%xmm0
call   1040 <dot2ang@plt>
addsd  0xc61(%rip),%xmm0
andpd  0xc39(%rip),%xmm0
movsd  0xc59(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbp)
mov    0x138(%rsp),%rax
ucomisd 0x20(%rax),%xmm1
ja     14dc <check_pair+0x2fc>
movsd  0xc3d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     140c <check_pair+0x22c>
movsd  0x10(%rbp),%xmm0
ucomisd 0xc32(%rip),%xmm0
jae    14dc <check_pair+0x2fc>
lea    0x90(%rsp),%rdi
call   10e0 <veclen@plt>
mov    0x138(%rsp),%rcx
movsd  %xmm0,0x20(%rbp)
movsd  0x28(%rcx),%xmm1
ucomisd %xmm0,%xmm1
ja     14dc <check_pair+0x2fc>
mov    0x150(%rsp),%rax
movsd  0x8(%rbp),%xmm2
movsd  0x10(%rbp),%xmm1
movapd %xmm1,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x28(%rbp)
test   %rax,%rax
je     148c <check_pair+0x2ac>
movsd  0x18(%rcx),%xmm2
ucomisd %xmm1,%xmm2
jb     14dc <check_pair+0x2fc>
movsd  0x20(%rcx),%xmm1
ucomisd 0x18(%rbp),%xmm1
jb     14dc <check_pair+0x2fc>
ucomisd 0x28(%rcx),%xmm0
jb     14dc <check_pair+0x2fc>
mov    0x148(%rsp),%rax
movq   $0x1,(%rax)
jmp    14dc <check_pair+0x2fc>
movsd  0xbac(%rip),%xmm3
ucomisd %xmm0,%xmm3
jb     14a4 <check_pair+0x2c4>
ucomisd 0xba6(%rip),%xmm1
jae    14dc <check_pair+0x2fc>
movsd  0x10(%rcx),%xmm3
ucomisd %xmm2,%xmm3
jb     14dc <check_pair+0x2fc>
movsd  0x18(%rcx),%xmm2
ucomisd %xmm1,%xmm2
jb     14dc <check_pair+0x2fc>
movsd  0x20(%rcx),%xmm1
ucomisd 0x18(%rbp),%xmm1
jb     14dc <check_pair+0x2fc>
ucomisd 0x28(%rcx),%xmm0
jb     14dc <check_pair+0x2fc>
mov    0x0(%r13,%r14,8),%rax
mov    0x8(%rax),%rcx
cmp    0x10(%rax),%rcx
jle    14ee <check_pair+0x30e>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x28(%rbp),%rax
mov    %rax,0x10(%rsp)
jmp    1520 <check_pair+0x340>
lea    0xb7d(%rip),%rsi
call   10c0 <strcmp@plt>
test   %rax,%rax
je     1584 <check_pair+0x3a4>
mov    (%rsp),%rdx
lea    0x1(%rdx),%rax
mov    0x0(%r13,%r14,8),%rcx
cmp    0x10(%rcx),%rdx
mov    %rax,%rcx
jge    14dc <check_pair+0x2fc>
mov    0x130(%rsp),%rax
mov    %rcx,(%rsp)
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%esi
lea    0xb40(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
jne    150a <check_pair+0x32a>
mov    0x130(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%esi
lea    0xb1b(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
jne    150a <check_pair+0x32a>
mov    0x130(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,8),%rdi
cmpb   $0x27,0x3(%rdi)
je     14f9 <check_pair+0x319>
mov    0x0(%r13,%rbx,8),%rax
mov    0x8(%rax),%rbp
cmp    0x10(%rax),%rbp
jg     150a <check_pair+0x32a>
add    $0xffffffffffffffff,%rbp
jmp    15c1 <check_pair+0x3e1>
lea    0xad9(%rip),%rsi
call   10c0 <strcmp@plt>
test   %rax,%rax
je     1618 <check_pair+0x438>
mov    0x0(%r13,%rbx,8),%rax
add    $0x1,%rbp
cmp    0x10(%rax),%rbp
jge    150a <check_pair+0x32a>
mov    0x130(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rax
movsbl 0x1(%rax),%esi
lea    0xaa2(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
jne    15ae <check_pair+0x3ce>
mov    0x130(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rax
movsbl 0x3(%rax),%esi
lea    0xa80(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
jne    15ae <check_pair+0x3ce>
mov    0x130(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rdi
cmpb   $0x27,0x3(%rdi)
je     159d <check_pair+0x3bd>
mov    0x130(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%esi
lea    0xa4f(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
je     15ae <check_pair+0x3ce>
mov    0x130(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,8),%rax
cmpb   $0x20,(%rax)
jne    15ae <check_pair+0x3ce>
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
test   %rax,%rax
je     15ae <check_pair+0x3ce>
mov    0x130(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rax
movsbl 0x1(%rax),%esi
lea    0x9fe(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
je     15ae <check_pair+0x3ce>
mov    0x130(%rsp),%rax
mov    0x8(%rax,%rbp,8),%rax
cmpb   $0x20,(%rax)
jne    15ae <check_pair+0x3ce>
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
test   %rax,%rax
je     15ae <check_pair+0x3ce>
mov    0x8(%r12,%rbp,8),%rax
mov    (%rsp),%rcx
mov    (%r12,%rcx,8),%rcx
movupd 0x8(%rax),%xmm0
movupd 0x8(%rcx),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x38(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x48(%rsp)
lea    0x30(%rsp),%rdi
call   10e0 <veclen@plt>
mov    0x138(%rsp),%rax
movsd  0x8(%rax),%xmm1
ucomisd %xmm0,%xmm1
jb     15ae <check_pair+0x3ce>
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10d0 <dmatrix@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10d0 <dmatrix@plt>
mov    %rax,0x58(%rsp)
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10d0 <dmatrix@plt>
mov    %rax,0x50(%rsp)
lea    0x28(%rsp),%rax
mov    %r14,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%rdx
mov    %r13,%rcx
mov    0x130(%rsp),%r8
mov    %r12,%r9
push   %rax
mov    0x148(%rsp),%rbp
push   %rbp
call   1080 <base_stack@plt>
add    $0x10,%rsp
cmpq   $0x0,0x28(%rsp)
jg     14dc <check_pair+0x2fc>
cvttsd2si 0x8(%rbp),%ecx
movsd  0x10(%rbp),%xmm0
movsd  0x18(%rbp),%xmm1
movsd  0x20(%rbp),%xmm2
lea    0x8c8(%rip),%rsi
mov    0x158(%rsp),%rdi
xor    %edx,%edx
mov    $0x3,%al
call   1100 <sprintf@plt>
mov    0x20(%rsp),%rbp
movsbl 0x0(%rbp,%r14,1),%edi
call   1070 <toupper@plt>
mov    %eax,%r12d
movsbl 0x0(%rbp,%rbx,1),%edi
call   1070 <toupper@plt>
lea    0x8b1(%rip),%rsi
lea    0xd(%rsp),%rdi
mov    %r12d,%edx
mov    %eax,%ecx
xor    %eax,%eax
call   1100 <sprintf@plt>
mov    0x148(%rsp),%rax
movq   $0xffffffffffffffff,(%rax)
xorpd  %xmm0,%xmm0
movsd  0x68(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    18b8 <check_pair+0x6d8>
ucomisd 0x60(%rsp),%xmm0
jbe    18b8 <check_pair+0x6d8>
xorpd  %xmm0,%xmm0
ucomisd 0x18(%rsp),%xmm0
jbe    18b8 <check_pair+0x6d8>
mov    0x148(%rsp),%rax
movq   $0x1,(%rax)
movsd  0x7fb(%rip),%xmm0
mov    0x140(%rsp),%rax
ucomisd 0x8(%rax),%xmm0
jb     18b8 <check_pair+0x6d8>
lea    0x2835(%rip),%rsi
lea    0xd(%rsp),%rdi
mov    $0x1,%edx
mov    $0x8,%ecx
call   1060 <num_strmatch@plt>
test   %rax,%rax
je     1895 <check_pair+0x6b5>
mov    0x148(%rsp),%rax
movq   $0x2,(%rax)
jmp    18a3 <check_pair+0x6c3>
mov    0x148(%rsp),%rax
cmpq   $0x2,(%rax)
jne    18b8 <check_pair+0x6d8>
mov    0x10(%rsp),%rax
movsd  (%rax),%xmm0
addsd  0x7a4(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    (%r15,%r14,8),%rcx
mov    (%r15,%rbx,8),%rax
movsd  0x38(%rcx),%xmm0
mov    0x140(%rsp),%r15
movsd  %xmm0,0x48(%r15)
movsd  0x38(%rax),%xmm0
movsd  %xmm0,0x60(%r15)
movsd  0x8(%rcx),%xmm0
mov    (%rsp),%r12
mov    0x8(%r12),%rbp
movsd  %xmm0,0x8(%rbp)
movsd  0x8(%rax),%xmm0
mov    0x58(%rsp),%r13
mov    0x8(%r13),%r8
movsd  %xmm0,0x8(%r8)
movsd  0x10(%rcx),%xmm0
mov    0x10(%r12),%rdx
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%rax),%xmm0
mov    0x10(%r13),%r9
movsd  %xmm0,0x8(%r9)
movsd  0x18(%rcx),%xmm0
mov    0x18(%r12),%rsi
movsd  %xmm0,0x8(%rsi)
movsd  0x18(%rax),%xmm0
mov    0x18(%r13),%rdi
movsd  %xmm0,0x8(%rdi)
movsd  0x40(%rcx),%xmm0
movsd  %xmm0,0x50(%r15)
movsd  0x40(%rax),%xmm0
movsd  %xmm0,0x68(%r15)
movsd  0x20(%rcx),%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x20(%rax),%xmm1
movaps 0x6a4(%rip),%xmm0
xorps  %xmm0,%xmm1
movlps %xmm1,0x10(%r8)
movsd  0x28(%rcx),%xmm1
movsd  %xmm1,0x10(%rdx)
movsd  0x28(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x10(%r9)
movsd  0x30(%rcx),%xmm1
movsd  %xmm1,0x10(%rsi)
movsd  0x30(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x10(%rdi)
movsd  0x48(%rcx),%xmm1
movsd  %xmm1,0x58(%r15)
movsd  0x48(%rax),%xmm1
movsd  %xmm1,0x70(%r15)
movsd  0x38(%rcx),%xmm1
movsd  %xmm1,0x18(%rbp)
movsd  0x38(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x18(%r8)
movsd  0x40(%rcx),%xmm1
movsd  %xmm1,0x18(%rdx)
movsd  0x40(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x18(%r9)
movsd  0x48(%rcx),%xmm1
movsd  %xmm1,0x18(%rsi)
movsd  0x48(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x18(%rdi)
mov    0x128(%rsp),%rax
mov    (%rax,%rbx,8),%rsi
mov    (%rax,%r14,8),%rcx
sub    $0x8,%rsp
lea    0xb8(%rsp),%r8
mov    %r13,%rdi
mov    %r12,%rdx
mov    0x58(%rsp),%rbx
mov    %rbx,%r9
push   0x18(%rsp)
call   10b0 <bpstep_par@plt>
add    $0x10,%rsp
movups 0xb8(%rsp),%xmm0
movups 0xc8(%rsp),%xmm1
movups 0xd8(%rsp),%xmm2
movups %xmm0,0x78(%r15)
movups %xmm1,0x88(%r15)
movups %xmm2,0x98(%r15)
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   10f0 <free_dmatrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   10f0 <free_dmatrix@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   10f0 <free_dmatrix@plt>
jmp    14dc <check_pair+0x2fc>

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

LLVM IR (-O2):
@check_pair.WC = internal global [9 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i32 0, i32 0)]
@.str = [3 x i8] c"XX\00"
@.str.1 = [3 x i8] c"AT\00"
@.str.2 = [3 x i8] c"AU\00"
@.str.3 = [3 x i8] c"TA\00"
@.str.4 = [3 x i8] c"UA\00"
@.str.5 = [3 x i8] c"GC\00"
@.str.6 = [3 x i8] c"CG\00"
@.str.7 = [3 x i8] c"IC\00"
@.str.8 = [3 x i8] c"CI\00"
@.str.9 = [2 x i8] c"P\00"
@.str.10 = [5 x i8] c" O2'\00"
@.str.11 = [3 x i8] c"ON\00"
@.str.12 = [30 x i8] c"%7.2f %7.2f %7.2f %7.2f %7.2f\00"
@.str.13 = [5 x i8] c"%c%c\00"
define void @check_pair(i64 %0, i64 %1, i8* %2, i64** %3, double** %4, double** nocapture %5, double** nocapture %6, double** nocapture %7, i8** %8, double* nocapture %9, double* %10, i64* nocapture %11, i64 %12, i8* nocapture writeonly %13) {
%15 = alloca [3 x i8]
%16 = alloca i64
%17 = alloca [7 x double]
%18 = alloca [4 x double]
%19 = alloca [4 x double]
%20 = alloca [4 x double]
%21 = getelementptr inbounds [3 x i8], [3 x i8]* %15, i64 0, i64 0
%22 = bitcast i64* %16 to i8*
store i64 0, i64* %16
%23 = bitcast [7 x double]* %17 to i8*
%24 = bitcast [4 x double]* %18 to i8*
%25 = bitcast [4 x double]* %19 to i8*
%26 = bitcast [4 x double]* %20 to i8*
store i64 0, i64* %11
%27 = icmp eq i64 %0, %1
br i1 %27, label %465, label %28
28: ; preds = %14
%29 = getelementptr inbounds double*, double** %7, i64 %1
%30 = load double*, double** %29
%31 = getelementptr inbounds double*, double** %7, i64 %0
%32 = load double*, double** %31
%33 = getelementptr inbounds double*, double** %5, i64 %1
%34 = load double*, double** %33
%35 = getelementptr inbounds double*, double** %5, i64 %0
%36 = load double*, double** %35
%37 = getelementptr inbounds double, double* %30, i64 1
%38 = load double, double* %37
%39 = getelementptr inbounds double, double* %32, i64 1
%40 = load double, double* %39
%41 = fsub double %38, %40
%42 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 1
store double %41, double* %42
%43 = getelementptr inbounds double, double* %34, i64 1
%44 = load double, double* %43
%45 = getelementptr inbounds double, double* %36, i64 1
%46 = load double, double* %45
%47 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 1
%48 = getelementptr inbounds double, double* %30, i64 2
%49 = load double, double* %48
%50 = getelementptr inbounds double, double* %32, i64 2
%51 = load double, double* %50
%52 = fsub double %49, %51
%53 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 2
store double %52, double* %53
%54 = getelementptr inbounds double, double* %34, i64 2
%55 = load double, double* %54
%56 = getelementptr inbounds double, double* %36, i64 2
%57 = load double, double* %56
%58 = insertelement <2 x double> poison, double %44, i64 0
%59 = insertelement <2 x double> %58, double %55, i64 1
%60 = insertelement <2 x double> poison, double %46, i64 0
%61 = insertelement <2 x double> %60, double %57, i64 1
%62 = fsub <2 x double> %59, %61
%63 = bitcast double* %47 to <2 x double>*
store <2 x double> %62, <2 x double>* %63
%64 = getelementptr inbounds double, double* %30, i64 3
%65 = load double, double* %64
%66 = getelementptr inbounds double, double* %32, i64 3
%67 = load double, double* %66
%68 = fsub double %65, %67
%69 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 3
store double %68, double* %69
%70 = getelementptr inbounds double, double* %34, i64 3
%71 = load double, double* %70
%72 = getelementptr inbounds double, double* %36, i64 3
%73 = load double, double* %72
%74 = fsub double %71, %73
%75 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 3
store double %74, double* %75
%76 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 0
%77 = call double @veclen(double* %76)
%78 = getelementptr inbounds double, double* %10, i64 1
store double %77, double* %78
%79 = getelementptr inbounds double*, double** %6, i64 %0
%80 = load double*, double** %79
%81 = getelementptr inbounds double*, double** %6, i64 %1
%82 = load double*, double** %81
%83 = call double @dot(double* %80, double* %82)
%84 = load double*, double** %79
%85 = getelementptr inbounds double, double* %84, i64 3
%86 = load double*, double** %81
%87 = getelementptr inbounds double, double* %86, i64 3
%88 = call double @dot(double* %85, double* %87)
%89 = load double*, double** %79
%90 = getelementptr inbounds double, double* %89, i64 6
%91 = load double*, double** %81
%92 = getelementptr inbounds double, double* %91, i64 6
%93 = call double @dot(double* %90, double* %92)
%94 = fcmp ugt double %93, 0.000000e+00
%95 = load double*, double** %79
%96 = load double*, double** %81
%97 = getelementptr inbounds double, double* %95, i64 7
%98 = load double, double* %97
%99 = getelementptr inbounds double, double* %96, i64 7
%100 = load double, double* %99
br i1 %94, label %118, label %101
101: ; preds = %28
%102 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 1
%103 = getelementptr inbounds double, double* %95, i64 8
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %96, i64 8
%106 = load double, double* %105
%107 = insertelement <2 x double> poison, double %98, i64 0
%108 = insertelement <2 x double> %107, double %104, i64 1
%109 = insertelement <2 x double> poison, double %100, i64 0
%110 = insertelement <2 x double> %109, double %106, i64 1
%111 = fsub <2 x double> %108, %110
%112 = bitcast double* %102 to <2 x double>*
store <2 x double> %111, <2 x double>* %112
%113 = getelementptr inbounds double, double* %95, i64 9
%114 = load double, double* %113
%115 = getelementptr inbounds double, double* %96, i64 9
%116 = load double, double* %115
%117 = fsub double %114, %116
br label %135
118: ; preds = %28
%119 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 1
%120 = getelementptr inbounds double, double* %95, i64 8
%121 = load double, double* %120
%122 = getelementptr inbounds double, double* %96, i64 8
%123 = load double, double* %122
%124 = insertelement <2 x double> poison, double %98, i64 0
%125 = insertelement <2 x double> %124, double %121, i64 1
%126 = insertelement <2 x double> poison, double %100, i64 0
%127 = insertelement <2 x double> %126, double %123, i64 1
%128 = fadd <2 x double> %125, %127
%129 = bitcast double* %119 to <2 x double>*
store <2 x double> %128, <2 x double>* %129
%130 = getelementptr inbounds double, double* %95, i64 9
%131 = load double, double* %130
%132 = getelementptr inbounds double, double* %96, i64 9
%133 = load double, double* %132
%134 = fadd double %131, %133
br label %135
135: ; preds = %101, %118
%136 = phi double [ %117, %101 ], [ %134, %118 ]
%137 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 3
store double %136, double* %137
%138 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 0
%139 = call i32 @vec_norm(double* %138)
%140 = call double @dot(double* %76, double* %138)
%141 = call double @llvm.fabs.f64(double %140)
%142 = getelementptr inbounds double, double* %10, i64 2
store double %141, double* %142
%143 = getelementptr inbounds double, double* %9, i64 3
%144 = load double, double* %143
%145 = fcmp ogt double %141, %144
br i1 %145, label %465, label %146
146: ; preds = %135
%147 = call double @dot2ang(double %93)
%148 = fadd double %147, -9.000000e+01
%149 = call double @llvm.fabs.f64(double %148)
%150 = fsub double 9.000000e+01, %149
%151 = getelementptr inbounds double, double* %10, i64 3
store double %150, double* %151
%152 = getelementptr inbounds double, double* %9, i64 4
%153 = load double, double* %152
%154 = fcmp ogt double %150, %153
br i1 %154, label %465, label %155
155: ; preds = %146
%156 = fcmp ugt double %150, 1.000000e+01
br i1 %156, label %160, label %157
157: ; preds = %155
%158 = load double, double* %142
%159 = fcmp ult double %158, 2.200000e+00
br i1 %159, label %160, label %465
160: ; preds = %157, %155
%161 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 0
%162 = call double @veclen(double* %161)
%163 = getelementptr inbounds double, double* %10, i64 4
store double %162, double* %163
%164 = getelementptr inbounds double, double* %9, i64 5
%165 = load double, double* %164
%166 = fcmp olt double %162, %165
br i1 %166, label %465, label %167
167: ; preds = %160
%168 = load double, double* %78
%169 = load double, double* %142
%170 = call double @llvm.fmuladd.f64(double %169, double 2.000000e+00, double %168)
%171 = getelementptr inbounds double, double* %10, i64 5
store double %170, double* %171
%172 = icmp eq i64 %12, 0
br i1 %172, label %184, label %173
173: ; preds = %167
%174 = load double, double* %143
%175 = fcmp ugt double %169, %174
br i1 %175, label %465, label %176
176: ; preds = %173
%177 = load double, double* %151
%178 = load double, double* %152
%179 = fcmp ugt double %177, %178
br i1 %179, label %465, label %180
180: ; preds = %176
%181 = load double, double* %164
%182 = fcmp ult double %162, %181
br i1 %182, label %465, label %183
183: ; preds = %180
store i64 1, i64* %11
br label %465
184: ; preds = %167
%185 = fcmp ugt double %162, 6.000000e+00
%186 = fcmp ult double %169, 1.800000e+00
%187 = select i1 %185, i1 true, i1 %186
br i1 %187, label %188, label %465
188: ; preds = %184
%189 = getelementptr inbounds double, double* %9, i64 2
%190 = load double, double* %189
%191 = fcmp ugt double %168, %190
br i1 %191, label %465, label %192
192: ; preds = %188
%193 = load double, double* %143
%194 = fcmp ugt double %169, %193
br i1 %194, label %465, label %195
195: ; preds = %192
%196 = load double, double* %151
%197 = load double, double* %152
%198 = fcmp ugt double %196, %197
br i1 %198, label %465, label %199
199: ; preds = %195
%200 = load double, double* %164
%201 = fcmp ult double %162, %200
br i1 %201, label %465, label %202
202: ; preds = %199
%203 = getelementptr inbounds i64*, i64** %3, i64 %0
%204 = load i64*, i64** %203
%205 = getelementptr inbounds i64, i64* %204, i64 1
%206 = load i64, i64* %205
%207 = getelementptr inbounds i64, i64* %204, i64 2
%208 = load i64, i64* %207
%209 = icmp sgt i64 %206, %208
br i1 %209, label %465, label %210
210: ; preds = %202
%211 = getelementptr inbounds i64*, i64** %3, i64 %1
%212 = getelementptr inbounds double, double* %9, i64 1
%213 = bitcast double* %42 to <2 x double>*
br label %214
214: ; preds = %210, %322
%215 = phi i64 [ %206, %210 ], [ %323, %322 ]
%216 = getelementptr inbounds i8*, i8** %8, i64 %215
%217 = load i8*, i8** %216
%218 = getelementptr inbounds i8, i8* %217, i64 1
%219 = load i8, i8* %218
%220 = call i64 @strchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8 signext %219)
%221 = icmp eq i64 %220, 0
br i1 %221, label %222, label %322
222: ; preds = %214
%223 = load i8*, i8** %216
%224 = getelementptr inbounds i8, i8* %223, i64 3
%225 = load i8, i8* %224
%226 = call i64 @strchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8 signext %225)
%227 = icmp eq i64 %226, 0
br i1 %227, label %228, label %322
228: ; preds = %222
%229 = load i8*, i8** %216
%230 = getelementptr inbounds i8, i8* %229, i64 3
%231 = load i8, i8* %230
%232 = icmp eq i8 %231, 39
br i1 %232, label %233, label %236
233: ; preds = %228
%234 = call i64 @strcmp(i8* %229, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%235 = icmp eq i64 %234, 0
br i1 %235, label %236, label %322
236: ; preds = %233, %228
%237 = load i64*, i64** %211
%238 = getelementptr inbounds i64, i64* %237, i64 1
%239 = load i64, i64* %238
%240 = getelementptr inbounds i64, i64* %237, i64 2
%241 = load i64, i64* %240
%242 = icmp sgt i64 %239, %241
br i1 %242, label %322, label %243
243: ; preds = %236
%244 = getelementptr inbounds double*, double** %4, i64 %215
br label %245
245: ; preds = %243, %316
%246 = phi i64 [ %239, %243 ], [ %317, %316 ]
%247 = getelementptr inbounds i8*, i8** %8, i64 %246
%248 = load i8*, i8** %247
%249 = getelementptr inbounds i8, i8* %248, i64 1
%250 = load i8, i8* %249
%251 = call i64 @strchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8 signext %250)
%252 = icmp eq i64 %251, 0
br i1 %252, label %253, label %316
253: ; preds = %245
%254 = load i8*, i8** %247
%255 = getelementptr inbounds i8, i8* %254, i64 3
%256 = load i8, i8* %255
%257 = call i64 @strchr(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8 signext %256)
%258 = icmp eq i64 %257, 0
br i1 %258, label %259, label %316
259: ; preds = %253
%260 = load i8*, i8** %247
%261 = getelementptr inbounds i8, i8* %260, i64 3
%262 = load i8, i8* %261
%263 = icmp eq i8 %262, 39
br i1 %263, label %264, label %267
264: ; preds = %259
%265 = call i64 @strcmp(i8* %260, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%266 = icmp eq i64 %265, 0
br i1 %266, label %267, label %316
267: ; preds = %264, %259
%268 = load i8*, i8** %216
%269 = getelementptr inbounds i8, i8* %268, i64 1
%270 = load i8, i8* %269
%271 = call i64 @strchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0), i8 signext %270)
%272 = icmp eq i64 %271, 0
br i1 %272, label %316, label %273
273: ; preds = %267
%274 = load i8*, i8** %216
%275 = load i8, i8* %274
%276 = icmp eq i8 %275, 32
br i1 %276, label %277, label %316
277: ; preds = %273
%278 = getelementptr inbounds i8, i8* %274, i64 2
%279 = load i8, i8* %278
%280 = call i64 @isdigit(i8 signext %279)
%281 = icmp eq i64 %280, 0
br i1 %281, label %316, label %282
282: ; preds = %277
%283 = load i8*, i8** %247
%284 = getelementptr inbounds i8, i8* %283, i64 1
%285 = load i8, i8* %284
%286 = call i64 @strchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0), i8 signext %285)
%287 = icmp eq i64 %286, 0
br i1 %287, label %316, label %288
288: ; preds = %282
%289 = load i8*, i8** %247
%290 = load i8, i8* %289
%291 = icmp eq i8 %290, 32
br i1 %291, label %292, label %316
292: ; preds = %288
%293 = getelementptr inbounds i8, i8* %289, i64 2
%294 = load i8, i8* %293
%295 = call i64 @isdigit(i8 signext %294)
%296 = icmp eq i64 %295, 0
br i1 %296, label %316, label %297
297: ; preds = %292
%298 = getelementptr inbounds double*, double** %4, i64 %246
%299 = load double*, double** %298
%300 = load double*, double** %244
%301 = getelementptr inbounds double, double* %299, i64 1
%302 = getelementptr inbounds double, double* %300, i64 1
%303 = bitcast double* %301 to <2 x double>*
%304 = load <2 x double>, <2 x double>* %303
%305 = bitcast double* %302 to <2 x double>*
%306 = load <2 x double>, <2 x double>* %305
%307 = fsub <2 x double> %304, %306
store <2 x double> %307, <2 x double>* %213
%308 = getelementptr inbounds double, double* %299, i64 3
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %300, i64 3
%311 = load double, double* %310
%312 = fsub double %309, %311
store double %312, double* %69
%313 = call double @veclen(double* %76)
%314 = load double, double* %212
%315 = fcmp ugt double %313, %314
br i1 %315, label %316, label %328
316: ; preds = %267, %273, %277, %282, %288, %292, %297, %264, %245, %253
%317 = add nsw i64 %246, 1
%318 = load i64*, i64** %211
%319 = getelementptr inbounds i64, i64* %318, i64 2
%320 = load i64, i64* %319
%321 = icmp slt i64 %246, %320
br i1 %321, label %245, label %322
322: ; preds = %316, %236, %233, %214, %222
%323 = add nsw i64 %215, 1
%324 = load i64*, i64** %203
%325 = getelementptr inbounds i64, i64* %324, i64 2
%326 = load i64, i64* %325
%327 = icmp slt i64 %215, %326
br i1 %327, label %214, label %465
328: ; preds = %297
%329 = call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
%330 = call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
%331 = call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
%332 = call i32 @base_stack(i64 %0, i64 %1, i8* %2, i64** %3, i8** %8, double** %4, double* %10, i64* %16)
%333 = load i64, i64* %16
%334 = icmp sgt i64 %333, 0
br i1 %334, label %465, label %335
335: ; preds = %328
%336 = load double, double* %78
%337 = fptosi double %336 to i32
%338 = load double, double* %142
%339 = load double, double* %151
%340 = load double, double* %163
%341 = call i32 (i8*, i8*, i32, i32, ...) @sprintf(i8* dereferenceable(1) %13, i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.12, i64 0, i64 0), i32 0, i32 %337, double %338, double %339, double %340)
%342 = getelementptr inbounds i8, i8* %2, i64 %0
%343 = load i8, i8* %342
%344 = call i32 @toupper(i8 signext %343)
%345 = getelementptr inbounds i8, i8* %2, i64 %1
%346 = load i8, i8* %345
%347 = call i32 @toupper(i8 signext %346)
%348 = call i32 (i8*, i8*, i32, i32, ...) @sprintf(i8* %21, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %344, i32 %347)
store i64 -1, i64* %11
%349 = fcmp ogt double %83, 0.000000e+00
%350 = fcmp olt double %88, 0.000000e+00
%351 = select i1 %349, i1 %350, i1 false
%352 = fcmp olt double %93, 0.000000e+00
%353 = select i1 %351, i1 %352, i1 false
br i1 %353, label %354, label %367
354: ; preds = %335
store i64 1, i64* %11
%355 = load double, double* %78
%356 = fcmp ugt double %355, 2.500000e+00
br i1 %356, label %367, label %357
357: ; preds = %354
%358 = call i64 @num_strmatch(i8* %21, i8** getelementptr inbounds ([9 x i8*], [9 x i8*]* @check_pair.WC, i64 0, i64 0), i32 1, i32 8)
%359 = icmp eq i64 %358, 0
br i1 %359, label %361, label %360
360: ; preds = %357
store i64 2, i64* %11
br label %364
361: ; preds = %357
%362 = load i64, i64* %11
%363 = icmp eq i64 %362, 2
br i1 %363, label %364, label %367
364: ; preds = %360, %361
%365 = load double, double* %171
%366 = fadd double %365, -1.500000e+00
store double %366, double* %171
br label %367
367: ; preds = %335, %354, %364, %361
%368 = load double*, double** %79
%369 = load double*, double** %81
%370 = getelementptr inbounds double, double* %368, i64 7
%371 = load double, double* %370
%372 = getelementptr inbounds double, double* %10, i64 9
store double %371, double* %372
%373 = getelementptr inbounds double, double* %369, i64 7
%374 = load double, double* %373
%375 = getelementptr inbounds double, double* %10, i64 12
store double %374, double* %375
%376 = getelementptr inbounds double, double* %368, i64 1
%377 = load double, double* %376
%378 = getelementptr inbounds double*, double** %329, i64 1
%379 = load double*, double** %378
%380 = getelementptr inbounds double, double* %379, i64 1
store double %377, double* %380
%381 = getelementptr inbounds double, double* %369, i64 1
%382 = load double, double* %381
%383 = getelementptr inbounds double*, double** %330, i64 1
%384 = load double*, double** %383
%385 = getelementptr inbounds double, double* %384, i64 1
store double %382, double* %385
%386 = getelementptr inbounds double, double* %368, i64 2
%387 = load double, double* %386
%388 = getelementptr inbounds double*, double** %329, i64 2
%389 = load double*, double** %388
%390 = getelementptr inbounds double, double* %389, i64 1
store double %387, double* %390
%391 = getelementptr inbounds double, double* %369, i64 2
%392 = load double, double* %391
%393 = getelementptr inbounds double*, double** %330, i64 2
%394 = load double*, double** %393
%395 = getelementptr inbounds double, double* %394, i64 1
store double %392, double* %395
%396 = getelementptr inbounds double, double* %368, i64 3
%397 = load double, double* %396
%398 = getelementptr inbounds double*, double** %329, i64 3
%399 = load double*, double** %398
%400 = getelementptr inbounds double, double* %399, i64 1
store double %397, double* %400
%401 = getelementptr inbounds double, double* %369, i64 3
%402 = load double, double* %401
%403 = getelementptr inbounds double*, double** %330, i64 3
%404 = load double*, double** %403
%405 = getelementptr inbounds double, double* %404, i64 1
store double %402, double* %405
%406 = getelementptr inbounds double, double* %368, i64 8
%407 = load double, double* %406
%408 = getelementptr inbounds double, double* %10, i64 10
store double %407, double* %408
%409 = getelementptr inbounds double, double* %369, i64 8
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %10, i64 13
store double %410, double* %411
%412 = getelementptr inbounds double, double* %368, i64 4
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %379, i64 2
store double %413, double* %414
%415 = getelementptr inbounds double, double* %369, i64 4
%416 = load double, double* %415
%417 = fneg double %416
%418 = getelementptr inbounds double, double* %384, i64 2
store double %417, double* %418
%419 = getelementptr inbounds double, double* %368, i64 5
%420 = load double, double* %419
%421 = getelementptr inbounds double, double* %389, i64 2
store double %420, double* %421
%422 = getelementptr inbounds double, double* %369, i64 5
%423 = load double, double* %422
%424 = fneg double %423
%425 = getelementptr inbounds double, double* %394, i64 2
store double %424, double* %425
%426 = getelementptr inbounds double, double* %368, i64 6
%427 = load double, double* %426
%428 = getelementptr inbounds double, double* %399, i64 2
store double %427, double* %428
%429 = getelementptr inbounds double, double* %369, i64 6
%430 = load double, double* %429
%431 = fneg double %430
%432 = getelementptr inbounds double, double* %404, i64 2
store double %431, double* %432
%433 = getelementptr inbounds double, double* %368, i64 9
%434 = load double, double* %433
%435 = getelementptr inbounds double, double* %10, i64 11
store double %434, double* %435
%436 = getelementptr inbounds double, double* %369, i64 9
%437 = load double, double* %436
%438 = getelementptr inbounds double, double* %10, i64 14
store double %437, double* %438
%439 = load double, double* %370
%440 = getelementptr inbounds double, double* %379, i64 3
store double %439, double* %440
%441 = load double, double* %373
%442 = fneg double %441
%443 = getelementptr inbounds double, double* %384, i64 3
store double %442, double* %443
%444 = load double, double* %406
%445 = getelementptr inbounds double, double* %389, i64 3
store double %444, double* %445
%446 = load double, double* %409
%447 = fneg double %446
%448 = getelementptr inbounds double, double* %394, i64 3
store double %447, double* %448
%449 = load double, double* %433
%450 = getelementptr inbounds double, double* %399, i64 3
store double %449, double* %450
%451 = load double, double* %436
%452 = fneg double %451
%453 = getelementptr inbounds double, double* %404, i64 3
store double %452, double* %453
%454 = load double*, double** %29
%455 = load double*, double** %31
%456 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 0
%457 = call i32 @bpstep_par(double** %330, double* %454, double** %329, double* %455, double* %456, double** %331, double* %171)
%458 = getelementptr double, double* %10, i64 15
%459 = bitcast double* %458 to i8*
%460 = getelementptr inbounds [7 x double], [7 x double]* %17, i64 0, i64 1
%461 = bitcast double* %460 to i8*
%462 = call i32 @free_dmatrix(double** %329, i32 1, i32 3, i32 1, i32 3)
%463 = call i32 @free_dmatrix(double** %330, i32 1, i32 3, i32 1, i32 3)
%464 = call i32 @free_dmatrix(double** %331, i32 1, i32 3, i32 1, i32 3)
br label %465
465: ; preds = %322, %202, %184, %188, %192, %195, %199, %367, %328, %173, %176, %180, %183, %160, %157, %146, %135, %14
ret void
}