#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*/ 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);
int toupper(char);
int /*<<< orphan*/ vec_norm(double *);
double veclen(double *);
void check_pairs(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 bpi[3];
  static char *WC[9] = {"XX", "AT", "AU", "TA", "UA", "GC", "CG", "IC", "CI"};
  double dd, dir_x, dir_y, dorg[4], zave[4], dNN_vec[4];
  long k, koffset, l, m, n, stack_key = 0;
  long short_contact = 0, without_H_m, with_H_m, without_H_n, with_H_n;
  *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;
  if (j == i + 1 && rtn_val[2] >= 2.0)
    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[1] <= BPRS[2]) {
    for (m = seidx[i][1]; m <= seidx[i][2] && !short_contact; m++) {
      for (n = seidx[j][1]; n <= seidx[j][2] && !short_contact; n++)
        if (strchr("ON", AtomName[m][1]) && strchr("ON", AtomName[n][1]) &&
            AtomName[m][0] == ' ' && isdigit(AtomName[m][2]) &&
            AtomName[m][3] == ' ' && AtomName[n][0] == ' ' &&
            isdigit(AtomName[n][2]) && AtomName[n][3] == ' ') {
          H_catalog(i, m, bseq, AtomName, &without_H_m, &with_H_m);
          H_catalog(j, n, bseq, AtomName, &without_H_n, &with_H_n);
          if (without_H_m == 1 && without_H_n == 1)
            continue;
          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) {
      double pars[7], **r1, **r2, **mst;
      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(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) &&
            rtn_val[3] <= 40 && rtn_val[2] < 1.5)
          *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_pairs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
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,-0xe0(%rbp)
movq   $0x0,-0xe8(%rbp)
mov    0x38(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    1253 <check_pairs+0x73>
jmp    1e3d <check_pairs+0xc5d>
movq   $0x1,-0xb8(%rbp)
cmpq   $0x3,-0xb8(%rbp)
03
jg     1300 <check_pairs+0x120>
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    125e <check_pairs+0x7e>
lea    -0x70(%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,-0x48(%rbp)
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,-0x50(%rbp)
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,-0x40(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
jb     1413 <check_pairs+0x233>
movq   $0x1,-0xb8(%rbp)
cmpq   $0x3,-0xb8(%rbp)
03
jg     140e <check_pairs+0x22e>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    13a1 <check_pairs+0x1c1>
jmp    1490 <check_pairs+0x2b0>
movq   $0x1,-0xb8(%rbp)
cmpq   $0x3,-0xb8(%rbp)
03
jg     148b <check_pairs+0x2ab>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    141e <check_pairs+0x23e>
jmp    1490 <check_pairs+0x2b0>
lea    -0x90(%rbp),%rdi
call   10a0 <vec_norm@plt>
lea    -0x70(%rbp),%rdi
lea    -0x90(%rbp),%rsi
call   1030 <dot@plt>
movaps 0xb4d(%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    14dd <check_pairs+0x2fd>
jmp    1e3d <check_pairs+0xc5d>
movsd  -0x40(%rbp),%xmm0
call   1040 <dot2ang@plt>
movaps %xmm0,%xmm1
movsd  0xb1e(%rip),%xmm0
subsd  %xmm0,%xmm1
movaps 0xb03(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb07(%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    1533 <check_pairs+0x353>
jmp    1e3d <check_pairs+0xc5d>
mov    0x30(%rbp),%rax
movsd  0xad9(%rip),%xmm0
ucomisd 0x18(%rax),%xmm0
jb     156a <check_pairs+0x38a>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xac5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     156a <check_pairs+0x38a>
jmp    1e3d <check_pairs+0xc5d>
lea    -0xb0(%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    15a0 <check_pairs+0x3c0>
jmp    1e3d <check_pairs+0xc5d>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    15d5 <check_pairs+0x3f5>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0xa62(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     15d5 <check_pairs+0x3f5>
jmp    1e3d <check_pairs+0xc5d>
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     1663 <check_pairs+0x483>
mov    0x30(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x18(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     165e <check_pairs+0x47e>
mov    0x30(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x20(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     165e <check_pairs+0x47e>
mov    0x30(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd 0x28(%rax),%xmm0
jb     165e <check_pairs+0x47e>
mov    0x38(%rbp),%rax
movq   $0x1,(%rax)
jmp    1e3d <check_pairs+0xc5d>
mov    0x30(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1e3d <check_pairs+0xc5d>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rdx
mov    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cmp    0x10(%rdx),%rcx
mov    %al,-0x159(%rbp)
jg     16ce <check_pairs+0x4ee>
cmpq   $0x0,-0xe8(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x159(%rbp)
mov    -0x159(%rbp),%al
test   $0x1,%al
jne    16e1 <check_pairs+0x501>
jmp    1993 <check_pairs+0x7b3>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    (%rax,%rdx,8),%rdx
xor    %eax,%eax
cmp    0x10(%rdx),%rcx
mov    %al,-0x15a(%rbp)
jg     1730 <check_pairs+0x550>
cmpq   $0x0,-0xe8(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x15a(%rbp)
mov    -0x15a(%rbp),%al
test   $0x1,%al
jne    1743 <check_pairs+0x563>
jmp    1977 <check_pairs+0x797>
mov    0x20(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x90a(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x8e1(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1090 <strchr@plt>
cmp    $0x0,%rax
je     195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%rax
je     195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x20,%eax
jne    195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%rax
je     195b <check_pairs+0x77b>
mov    0x20(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x20,%eax
jne    195b <check_pairs+0x77b>
mov    -0x8(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    0x20(%rbp),%rcx
lea    -0xf0(%rbp),%r8
lea    -0xf8(%rbp),%r9
call   10d0 <H_catalog@plt>
mov    -0x10(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    0x20(%rbp),%rcx
lea    -0x100(%rbp),%r8
lea    -0x108(%rbp),%r9
call   10d0 <H_catalog@plt>
cmpq   $0x1,-0xf0(%rbp)
01
jne    18b4 <check_pairs+0x6d4>
cmpq   $0x1,-0x100(%rbp)
01
jne    18b4 <check_pairs+0x6d4>
jmp    1960 <check_pairs+0x780>
movq   $0x1,-0xb8(%rbp)
cmpq   $0x3,-0xb8(%rbp)
03
jg     1927 <check_pairs+0x747>
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    18bf <check_pairs+0x6df>
lea    -0x70(%rbp),%rdi
call   10e0 <veclen@plt>
movaps %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1956 <check_pairs+0x776>
movq   $0x1,-0xe8(%rbp)
jmp    1977 <check_pairs+0x797>
jmp    195b <check_pairs+0x77b>
jmp    1960 <check_pairs+0x780>
mov    -0xd8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd8(%rbp)
jmp    16f8 <check_pairs+0x518>
jmp    197c <check_pairs+0x79c>
mov    -0xd0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd0(%rbp)
jmp    1696 <check_pairs+0x4b6>
cmpq   $0x0,-0xe8(%rbp)
je     1e38 <check_pairs+0xc58>
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <dmatrix@plt>
mov    %rax,-0x148(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <dmatrix@plt>
mov    %rax,-0x150(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10c0 <dmatrix@plt>
mov    %rax,-0x158(%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    -0xe0(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1080 <base_stack@plt>
cmpq   $0x0,-0xe0(%rbp)
jle    1a33 <check_pairs+0x853>
jmp    1e3d <check_pairs+0xc5d>
lea    -0x33(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <toupper@plt>
mov    %eax,-0x160(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <toupper@plt>
mov    -0x168(%rbp),%rdi
mov    -0x160(%rbp),%edx
mov    %eax,%ecx
lea    0x5ea(%rip),%rsi
call   1100 <sprintf@plt>
mov    0x38(%rbp),%rax
movq   $0xffffffffffffffff,(%rax)
movsd  -0x48(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x15b(%rbp)
jbe    1acd <check_pairs+0x8ed>
xor    %eax,%eax
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
mov    %al,-0x15b(%rbp)
jbe    1acd <check_pairs+0x8ed>
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
seta   %al
mov    %al,-0x15b(%rbp)
mov    -0x15b(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    %rax,-0xb8(%rbp)
cmpq   $0x0,-0xb8(%rbp)
je     1b73 <check_pairs+0x993>
mov    0x38(%rbp),%rax
movq   $0x1,(%rax)
mov    0x30(%rbp),%rax
movsd  0x52a(%rip),%xmm0
ucomisd 0x8(%rax),%xmm0
jb     1b6e <check_pairs+0x98e>
lea    -0x33(%rbp),%rdi
lea    0x2584(%rip),%rsi
mov    $0x1,%edx
mov    $0x8,%ecx
call   1060 <num_strmatch@plt>
cmp    $0x0,%rax
je     1b6e <check_pairs+0x98e>
mov    0x30(%rbp),%rax
movsd  0x4f7(%rip),%xmm0
ucomisd 0x18(%rax),%xmm0
jb     1b6e <check_pairs+0x98e>
mov    0x30(%rbp),%rax
movsd  0x4e8(%rip),%xmm0
ucomisd 0x10(%rax),%xmm0
jbe    1b6e <check_pairs+0x98e>
mov    0x38(%rbp),%rax
movq   $0x2,(%rax)
jmp    1b73 <check_pairs+0x993>
mov    0x38(%rbp),%rax
cmpq   $0x2,(%rax)
jne    1b9b <check_pairs+0x9bb>
mov    0x30(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  0x4ae(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rax)
movq   $0x1,-0xb8(%rbp)
cmpq   $0x3,-0xb8(%rbp)
03
jg     1d4b <check_pairs+0xb6b>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movsd  %xmm0,0x40(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
add    $0x6,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movsd  %xmm0,0x58(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
sub    $0x1,%rax
imul   $0x3,%rax,%rax
mov    %rax,-0xc0(%rbp)
movq   $0x1,-0xc8(%rbp)
cmpq   $0x3,-0xc8(%rbp)
03
jg     1d2f <check_pairs+0xb4f>
mov    0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
add    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x148(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpq   $0x1,-0xb8(%rbp)
01
jne    1cb4 <check_pairs+0xad4>
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
add    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1cf2 <check_pairs+0xb12>
mov    0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
add    -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc8(%rbp)
jmp    1c2f <check_pairs+0xa4f>
jmp    1d34 <check_pairs+0xb54>
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    1ba6 <check_pairs+0x9c6>
mov    -0x150(%rbp),%rdi
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x148(%rbp),%rdx
mov    0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    -0x140(%rbp),%r8
mov    -0x158(%rbp),%r9
mov    0x30(%rbp),%rax
add    $0x28,%rax
mov    %rax,(%rsp)
call   10b0 <bpstep_par@plt>
movq   $0x1,-0xb8(%rbp)
cmpq   $0x6,-0xb8(%rbp)
06
jg     1de4 <check_pairs+0xc04>
mov    -0xb8(%rbp),%rax
movsd  -0x140(%rbp,%rax,8),%xmm0
ff ff
mov    0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
add    $0xe,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb8(%rbp)
jmp    1d9b <check_pairs+0xbbb>
mov    -0x148(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
mov    -0x150(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
mov    -0x158(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10f0 <free_dmatrix@plt>
jmp    1e3d <check_pairs+0xc5d>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_pairs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r8,0x30(%rsp)
mov    %rdx,0x20(%rsp)
mov    0x178(%rsp),%rax
movq   $0x0,0x38(%rsp)
movq   $0x0,(%rax)
cmp    %rsi,%rdi
je     1a47 <check_pairs+0x867>
mov    %rcx,%r13
mov    %rsi,%rbx
mov    %rdi,%r14
mov    0x170(%rsp),%r12
mov    0x158(%rsp),%rcx
mov    0x150(%rsp),%rbp
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,0x48(%rsp)
movsd  0x10(%rax),%xmm0
subsd  0x10(%rcx),%xmm0
movsd  0x8(%rdx),%xmm1
movsd  0x8(%rsi),%xmm2
movsd  %xmm0,0x50(%rsp)
movhpd 0x10(%rdx),%xmm1
movhpd 0x10(%rsi),%xmm2
subpd  %xmm2,%xmm1
movupd %xmm1,0xc8(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x18(%rdx),%xmm0
subsd  0x18(%rsi),%xmm0
movsd  %xmm0,0xd8(%rsp)
lea    0x40(%rsp),%rdi
call   10e0 <veclen@plt>
movsd  %xmm0,0x8(%r12)
mov    0x0(%rbp,%r14,8),%rdi
mov    0x0(%rbp,%rbx,8),%rsi
call   1030 <dot@plt>
movsd  %xmm0,0x78(%rsp)
mov    0x0(%rbp,%r14,8),%rdi
add    $0x18,%rdi
mov    0x0(%rbp,%rbx,8),%rsi
add    $0x18,%rsi
call   1030 <dot@plt>
movsd  %xmm0,0x70(%rsp)
mov    0x0(%rbp,%r14,8),%rdi
add    $0x30,%rdi
mov    0x0(%rbp,%rbx,8),%rsi
add    $0x30,%rsi
call   1030 <dot@plt>
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x28(%rsp)
ucomisd %xmm0,%xmm1
mov    0x0(%rbp,%r14,8),%rcx
mov    0x0(%rbp,%rbx,8),%rax
movsd  0x38(%rcx),%xmm0
movsd  0x38(%rax),%xmm1
jae    1352 <check_pairs+0x172>
movhpd 0x40(%rcx),%xmm0
movhpd 0x40(%rax),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x98(%rsp)
movsd  0x48(%rcx),%xmm0
addsd  0x48(%rax),%xmm0
jmp    1373 <check_pairs+0x193>
movhpd 0x40(%rcx),%xmm0
movhpd 0x40(%rax),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x98(%rsp)
movsd  0x48(%rcx),%xmm0
subsd  0x48(%rax),%xmm0
movsd  %xmm0,0xa8(%rsp)
lea    0x90(%rsp),%rbp
mov    %rbp,%rdi
call   10a0 <vec_norm@plt>
lea    0x40(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <dot@plt>
andpd  0xc5f(%rip),%xmm0
movlpd %xmm0,0x10(%r12)
mov    0x168(%rsp),%rbp
ucomisd 0x18(%rbp),%xmm0
ja     1a47 <check_pairs+0x867>
movsd  0x28(%rsp),%xmm0
call   1040 <dot2ang@plt>
addsd  0xc52(%rip),%xmm0
andpd  0xc2a(%rip),%xmm0
movsd  0xc4a(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r12)
ucomisd 0x20(%rbp),%xmm1
ja     1a47 <check_pairs+0x867>
movsd  0xc34(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1417 <check_pairs+0x237>
movsd  0x10(%r12),%xmm0
ucomisd 0xc27(%rip),%xmm0
jae    1a47 <check_pairs+0x867>
lea    0xc0(%rsp),%rdi
call   10e0 <veclen@plt>
movsd  %xmm0,0x20(%r12)
movsd  0x28(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1a47 <check_pairs+0x867>
lea    0x1(%r14),%rax
movsd  0x10(%r12),%xmm1
cmp    %rbx,%rax
jne    1458 <check_pairs+0x278>
ucomisd 0xbee(%rip),%xmm1
jae    1a47 <check_pairs+0x867>
mov    0x180(%rsp),%rax
movsd  0x8(%r12),%xmm2
movapd %xmm1,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x28(%r12)
test   %rax,%rax
je     14bf <check_pairs+0x2df>
movsd  0x18(%rbp),%xmm2
ucomisd %xmm1,%xmm2
jb     1a47 <check_pairs+0x867>
movsd  0x20(%rbp),%xmm1
ucomisd 0x18(%r12),%xmm1
jb     1a47 <check_pairs+0x867>
ucomisd 0x28(%rbp),%xmm0
jb     1a47 <check_pairs+0x867>
mov    0x178(%rsp),%rax
movq   $0x1,(%rax)
jmp    1a47 <check_pairs+0x867>
movsd  0x10(%rbp),%xmm0
ucomisd %xmm2,%xmm0
jb     1a47 <check_pairs+0x867>
mov    0x0(%r13,%r14,8),%rax
mov    0x8(%rax),%r15
cmp    0x10(%rax),%r15
jg     1a47 <check_pairs+0x867>
mov    0x160(%rsp),%rbp
lea    0x28(%r12),%rcx
mov    %rcx,0x68(%rsp)
mov    0x0(%r13,%rbx,8),%rcx
mov    0x8(%rcx),%r12
cmp    0x10(%rcx),%r12
jle    1577 <check_pairs+0x397>
xor    %ecx,%ecx
jmp    1669 <check_pairs+0x489>
mov    0x30(%rsp),%rcx
mov    (%rcx,%r12,8),%rax
mov    (%rcx,%r15,8),%rcx
movupd 0x8(%rax),%xmm0
movupd 0x8(%rcx),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm0,0x48(%rsp)
movsd  0x18(%rax),%xmm0
subsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
lea    0x40(%rsp),%rdi
call   10e0 <veclen@plt>
mov    0x168(%rsp),%rax
movsd  0x8(%rax),%xmm1
ucomisd %xmm0,%xmm1
jae    1686 <check_pairs+0x4a6>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%rax
mov    0x0(%r13,%rbx,8),%rcx
cmp    0x10(%rcx),%r12
mov    %rax,%r12
jge    1662 <check_pairs+0x482>
mov    0x0(%rbp,%r15,8),%rax
movsbl 0x1(%rax),%esi
lea    0xafc(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
je     1560 <check_pairs+0x380>
mov    0x0(%rbp,%r12,8),%rax
movsbl 0x1(%rax),%esi
lea    0xae2(%rip),%rdi
call   1090 <strchr@plt>
test   %rax,%rax
je     1560 <check_pairs+0x380>
mov    0x0(%rbp,%r15,8),%rax
cmpb   $0x20,(%rax)
jne    1560 <check_pairs+0x380>
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
test   %rax,%rax
je     1560 <check_pairs+0x380>
mov    0x0(%rbp,%r15,8),%rax
cmpb   $0x20,0x3(%rax)
jne    1560 <check_pairs+0x380>
mov    0x0(%rbp,%r12,8),%rax
cmpb   $0x20,(%rax)
jne    1560 <check_pairs+0x380>
movsbl 0x2(%rax),%edi
call   1050 <isdigit@plt>
test   %rax,%rax
je     1560 <check_pairs+0x380>
mov    0x0(%rbp,%r12,8),%rax
cmpb   $0x20,0x3(%rax)
jne    1560 <check_pairs+0x380>
mov    %r14,%rdi
mov    %r15,%rsi
mov    0x20(%rsp),%rdx
mov    %rbp,%rcx
lea    0x88(%rsp),%r8
lea    0xb8(%rsp),%r9
call   10d0 <H_catalog@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x20(%rsp),%rdx
mov    %rbp,%rcx
lea    0x80(%rsp),%r8
lea    0xb0(%rsp),%r9
call   10d0 <H_catalog@plt>
cmpq   $0x1,0x88(%rsp)
jne    1509 <check_pairs+0x329>
cmpq   $0x1,0x80(%rsp)
je     1560 <check_pairs+0x380>
jmp    1509 <check_pairs+0x329>
xor    %ecx,%ecx
mov    0x0(%r13,%r14,8),%rax
mov    0x170(%rsp),%r12
cmp    0x10(%rax),%r15
jge    168d <check_pairs+0x4ad>
add    $0x1,%r15
test   %rcx,%rcx
je     14f3 <check_pairs+0x313>
jmp    168d <check_pairs+0x4ad>
mov    $0x1,%ecx
jmp    1664 <check_pairs+0x484>
test   %rcx,%rcx
je     1a47 <check_pairs+0x867>
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10c0 <dmatrix@plt>
mov    %rax,0x60(%rsp)
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10c0 <dmatrix@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   10c0 <dmatrix@plt>
mov    %rax,0x10(%rsp)
lea    0x38(%rsp),%rax
mov    %r14,%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%r15
mov    %r15,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
mov    0x30(%rsp),%r9
push   %rax
push   %r12
call   1080 <base_stack@plt>
add    $0x10,%rsp
cmpq   $0x0,0x38(%rsp)
jg     1a47 <check_pairs+0x867>
mov    0x60(%rsp),%r13
movsbl (%r15,%r14,1),%edi
call   1070 <toupper@plt>
mov    %eax,%ebp
movsbl (%r15,%rbx,1),%edi
call   1070 <toupper@plt>
lea    0x93e(%rip),%rsi
lea    0xd(%rsp),%rdi
mov    %ebp,%edx
mov    %eax,%ecx
call   1100 <sprintf@plt>
mov    0x178(%rsp),%rbp
movq   $0xffffffffffffffff,0x0(%rbp)
ff
xorpd  %xmm0,%xmm0
movsd  0x78(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    0x68(%rsp),%r11
jbe    1824 <check_pairs+0x644>
ucomisd 0x70(%rsp),%xmm0
jbe    1824 <check_pairs+0x644>
xorpd  %xmm0,%xmm0
ucomisd 0x28(%rsp),%xmm0
jbe    1824 <check_pairs+0x644>
movq   $0x1,0x0(%rbp)
movsd  0x89d(%rip),%xmm0
ucomisd 0x8(%r12),%xmm0
mov    %r13,%rdi
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%r9
jb     184a <check_pairs+0x66a>
lea    0x28d4(%rip),%rsi
lea    0xd(%rsp),%rdi
mov    $0x1,%edx
mov    $0x8,%ecx
mov    %r11,%r15
call   1060 <num_strmatch@plt>
mov    %r15,%r11
test   %rax,%rax
je     1824 <check_pairs+0x644>
movsd  0x85d(%rip),%xmm0
ucomisd 0x18(%r12),%xmm0
jb     1824 <check_pairs+0x644>
movsd  0x854(%rip),%xmm0
ucomisd 0x10(%r12),%xmm0
jbe    1824 <check_pairs+0x644>
movq   $0x2,0x0(%rbp)
mov    %r13,%rdi
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%r9
jmp    1838 <check_pairs+0x658>
cmpq   $0x2,0x0(%rbp)
mov    %r13,%rdi
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%r9
jne    184a <check_pairs+0x66a>
movsd  (%r11),%xmm0
addsd  0x81b(%rip),%xmm0
movsd  %xmm0,(%r11)
mov    0x150(%rsp),%rax
mov    (%rax,%r14,8),%rcx
mov    (%rax,%rbx,8),%rax
movsd  0x38(%rcx),%xmm0
movsd  %xmm0,0x48(%r12)
movsd  0x38(%rax),%xmm0
movsd  %xmm0,0x60(%r12)
movsd  0x8(%rcx),%xmm0
mov    0x8(%rdi),%rbp
movsd  %xmm0,0x8(%rbp)
movsd  0x8(%rax),%xmm0
mov    0x8(%r15),%r8
movsd  %xmm0,0x8(%r8)
movsd  0x10(%rcx),%xmm0
mov    0x10(%rdi),%rdx
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%rax),%xmm0
mov    0x10(%r15),%r10
movsd  %xmm0,0x8(%r10)
movsd  0x18(%rcx),%xmm0
mov    0x18(%rdi),%rsi
movsd  %xmm0,0x8(%rsi)
movsd  0x18(%rax),%xmm0
mov    %rdi,%r13
mov    0x18(%r15),%rdi
movsd  %xmm0,0x8(%rdi)
movsd  0x40(%rcx),%xmm0
movsd  %xmm0,0x50(%r12)
movsd  0x40(%rax),%xmm0
movsd  %xmm0,0x68(%r12)
movsd  0x20(%rcx),%xmm0
movsd  %xmm0,0x10(%rbp)
movsd  0x20(%rax),%xmm1
movaps 0x717(%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(%r10)
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(%r12)
movsd  0x48(%rax),%xmm1
movsd  %xmm1,0x70(%r12)
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(%r10)
movsd  0x48(%rcx),%xmm1
movsd  %xmm1,0x18(%rsi)
movsd  0x48(%rax),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,0x18(%rdi)
mov    0x158(%rsp),%rax
mov    (%rax,%rbx,8),%rsi
mov    (%rax,%r14,8),%rcx
sub    $0x8,%rsp
lea    0xe8(%rsp),%r8
mov    %r15,%rdi
mov    %r13,%rdx
push   %r11
mov    %r9,%rbx
call   10b0 <bpstep_par@plt>
add    $0x10,%rsp
movupd 0xe8(%rsp),%xmm0
movupd 0xf8(%rsp),%xmm1
movupd 0x108(%rsp),%xmm2
movupd %xmm0,0x78(%r12)
movupd %xmm1,0x88(%r12)
movupd %xmm2,0x98(%r12)
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   10f0 <free_dmatrix@plt>
mov    %r15,%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>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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