#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 */
char ConvertState(char *);
int /*<<< orphan*/ Hbond_pair(long, long, long **, char **, char *, double **,
                              double, long *, char **, char **, double *, long,
                              long);
int /*<<< orphan*/ LW_Saenger_correspond(char, char, char *, char *);
int /*<<< orphan*/ LW_pair_type(long, long, double, long **, char **, char *,
                                double **, char *, char **, char **, double *,
                                char *);
int /*<<< orphan*/ base_stack(long, long, char *, long **, char **, double **,
                              double *, long *);
int /*<<< orphan*/ bp_network(long, long *, long **, char **, char **, char *,
                              long *, char **, double **, char *, long **,
                              double **, double **, double **, double *, long *,
                              long *, long **);
int /*<<< orphan*/ check_pairs(long, long, char *, long **, double **,
                               double **, double **, double **, char **,
                               double *, double *, long *, int /*<<< orphan*/);
char **cmatrix(int /*<<< orphan*/, long, int /*<<< orphan*/, int);
double *dvector(int /*<<< orphan*/, int);
int /*<<< orphan*/ free_cmatrix(char **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_lmatrix(long **, int /*<<< orphan*/, long,
                                int /*<<< orphan*/, long);
int /*<<< orphan*/ free_lvector(long *, int /*<<< orphan*/, long);
int /*<<< orphan*/ get_unequility(long, char **, long *, char **);
int /*<<< orphan*/ hb_crt_alt(double *, char *, char *);
long **lmatrix(int /*<<< orphan*/, long, int /*<<< orphan*/, long);
long *lvector(int /*<<< orphan*/, long);
char *malloc(int);
int /*<<< orphan*/ sprintf(char *, char *, ...);
scalar_t__ strchr(char *, char);
int /*<<< orphan*/ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
scalar_t__ strstr(char *, char *);
int /*<<< orphan*/ syn_or_anti(long, char **, long **, double **, long *,
                               long *);
char toupper(char);
char *all_pairs(char *pdbfile, long num_residue, long *RY, double **Nxyz,
                double **orien, double **org, double *BPRS, long **seidx,
                double **xyz, char **AtomName, char **ResName, char *ChainID,
                long *ResSeq, char **Miscs, char *bseq, long *num_pair_tot,
                char **pair_type, long **bs_pairs_tot, long *num_single_base,
                long *single_base, long *num_multi, long *multi_idx,
                long **multi, long *sugar_syn) {
  char HB_ATOM[512], pa_int = ' ', corresp[20];
  char b1[512], b2[512], **atom, work_num[20], tmp_str[5];
  char **hb_atom1, **hb_atom2, type[20], syn_i[20], syn_j[20];
  char str[256], **base_single, **base_sugar, **base_p, **other;
  long nb_single = 0, nb_sugar = 0, nb_p = 0, nb_other = 0, nc1, nc2;
  long bpid_lu = 0, i, ir, j, jr, k, num_bp = 0;
  long nh, stack_key = 0, c_key, bone_key;
  long **pair_info, *prot_rna, nh1 = 0, nh2 = 0, nnh = 0;
  double rtn_val[21], HB_UPPER[2], *hb_dist, change, geo_check;
  char *profile;
  profile = malloc(sizeof(char) * (num_residue + 1));
  for (i = 0; i < num_residue; i++)
    profile[i] = '.';
  profile[num_residue] = '\0';
  base_single = cmatrix(0, num_residue, 0, 120);
  base_sugar = cmatrix(0, num_residue, 0, 120);
  base_p = cmatrix(0, num_residue, 0, 120);
  other = cmatrix(0, num_residue, 0, 120);
  hb_atom1 = cmatrix(0, 512, 0, 4);
  hb_atom2 = cmatrix(0, 512, 0, 4);
  hb_dist = dvector(0, 512);
  hb_crt_alt(HB_UPPER, HB_ATOM, b1);
  pair_info = lmatrix(0, num_residue, 0, 101L);
  prot_rna = lvector(0, num_residue);
  for (i = 0; i <= num_residue; i++)
    for (j = 0; j <= 101L; j++)
      pair_info[i][j] = 0;
  for (i = 0; i < 512; i++) {
    strcpy(hb_atom1[i], "");
    strcpy(hb_atom2[i], "");
    hb_dist[i] = 0;
  }
  for (i = 1; i <= num_residue; i++) {
    prot_rna[i] = 0;
    sugar_syn[i] = 0;
  }
  syn_or_anti(num_residue, AtomName, seidx, xyz, RY, sugar_syn);
  for (i = 1; i < num_residue; i++) {
    for (j = i + 1; j <= num_residue; j++) {
      ir = seidx[i][1];
      jr = seidx[j][1];
      if (sugar_syn[i] == 1) {
        sprintf(syn_i, "%3s ", "syn");
      } else {
        strcpy(syn_i, "  ");
      }
      if (sugar_syn[j] == 1) {
        sprintf(syn_j, "%3s ", "syn");
      } else {
        strcpy(syn_j, "  ");
      }
      check_pairs(i, j, bseq, seidx, xyz, Nxyz, orien, org, AtomName, BPRS,
                  rtn_val, &bpid_lu, 0);
      if (bpid_lu) {
        ir = seidx[i][1];
        jr = seidx[j][1];
        sprintf(work_num, "%d_%d", i, j);
        change = 0.35;
        c_key = 1;
        bone_key = 0;
        Hbond_pair(i, j, seidx, AtomName, bseq, xyz, change, &nh, hb_atom1,
                   hb_atom2, hb_dist, c_key, bone_key);
        nnh = 0;
        for (k = 1; k <= nh; k++) {
          if (hb_atom1[k][3] != ' ' && hb_atom2[k][3] != ' ')
            continue;
          nnh++;
        }
        if (nnh == 1) {
          if (nb_single++ > num_residue - 2) {
            return 0;
          }
          geo_check = 5.2;
          LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                       hb_atom1, hb_atom2, hb_dist, type);
          sprintf(str, "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !1H(b_b)\n",
                  work_num, ChainID[ir], ResSeq[ir], bseq[i], bseq[j],
                  ResSeq[jr], ChainID[jr], type, pa_int, syn_i, syn_j);
          strcpy(base_single[nb_single], str);
          continue;
        } else {
          atom = cmatrix(0, nh, 0, 4);
          get_unequility(nh, hb_atom1, &nh1, atom);
          get_unequility(nh, hb_atom2, &nh2, atom);
          free_cmatrix(atom, 0, nh, 0, 4);
          if ((nh1 == 1 && nh2 > 1) || (nh2 == 1 && nh1 > 1)) {
            if ((rtn_val[2] > BPRS[3] - 0.6) || (rtn_val[3] > BPRS[4] - 20)) {
              if (nb_single++ > num_residue - 2) {
                return 0;
              }
              geo_check = 5.0;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
              sprintf(str, "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !1H(b_b).\n",
                      work_num, ChainID[ir], ResSeq[ir], bseq[i], bseq[j],
                      ResSeq[jr], ChainID[jr], type, pa_int, syn_i, syn_j);
              strcpy(base_single[nb_single], str);
              continue;
            }
            geo_check = 4.329;
            LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                         hb_atom1, hb_atom2, hb_dist, type);
            sprintf(tmp_str, "%c%c%c", type[0], type[2], type[4]);
            if (strstr(tmp_str, ".") || strstr(tmp_str, "?") ||
                (rtn_val[2] > BPRS[3] - 0.4) || (rtn_val[3] > BPRS[4] - 15)) {
              if (nb_single++ > num_residue - 2) {
                return 0;
              }
              geo_check = 5.0;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
              sprintf(str, "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !1H(b_b).\n",
                      work_num, ChainID[ir], ResSeq[ir], bseq[i], bseq[j],
                      ResSeq[jr], ChainID[jr], type, pa_int, syn_i, syn_j);
              strcpy(base_single[nb_single], str);
              continue;
            }
          } else {
            if (bpid_lu == 2) {
              if ((toupper(bseq[i]) == 'A' &&
                   (toupper(bseq[j]) == 'U' || toupper(bseq[j]) == 'T')) ||
                  (toupper(bseq[j]) == 'A' &&
                   (toupper(bseq[i]) == 'U' || toupper(bseq[i]) == 'T'))) {
                strcpy(type, "-/- cis ");
              } else if ((toupper(bseq[i]) == 'G' && toupper(bseq[j]) == 'C') ||
                         (toupper(bseq[j]) == 'G' && toupper(bseq[i]) == 'C')) {
                strcpy(type, "+/+ cis ");
              } else {
                strcpy(type, "X/X cis ");
              }
            } else if (bpid_lu == 1 || bpid_lu == -1) {
              geo_check = 4.1;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
              sprintf(tmp_str, "%c%c%c", type[0], type[2], type[4]);
              if (strstr(tmp_str, ".") || strstr(tmp_str, "?")) {
                geo_check = 4.3;
                LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz,
                             bseq, hb_atom1, hb_atom2, hb_dist, type);
              }
            }
          }
          LW_Saenger_correspond(bseq[i], bseq[j], type, corresp);
          profile[i - 1] = ConvertState(type);
          profile[j - 1] = ConvertState(type);
          num_bp++;
          sprintf(tmp_str, "%c%c%c", type[0], type[2], type[4]);
          strcpy(pair_type[num_bp], tmp_str);
          if (num_bp >= 2 * num_residue) {
            return 0;
          }
          bs_pairs_tot[num_bp][1] = i;
          bs_pairs_tot[num_bp][2] = j;
        }
        if (++pair_info[i][101L] >= 101L) {
          --pair_info[i][101L];
          break;
        } else
          pair_info[i][pair_info[i][101L]] = j;
        if (++pair_info[j][101L] >= 101L) {
          --pair_info[j][101L];
          break;
        } else
          pair_info[j][pair_info[j][101L]] = i;
      } else if (bpid_lu == 0) {
        ir = seidx[i][1];
        jr = seidx[j][1];
        sprintf(work_num, "%d_%d", i, j);
        if (rtn_val[1] > BPRS[2])
          continue;
        if (rtn_val[2] > BPRS[3] + 0.3)
          continue;
        if (rtn_val[3] > BPRS[4])
          continue;
        base_stack(i, j, bseq, seidx, AtomName, xyz, rtn_val, &stack_key);
        if (stack_key > 0) {
          if (rtn_val[3] < 40) {
            profile[i - 1] = ConvertState(" stacked ");
            profile[j - 1] = ConvertState(" stacked ");
          }
          continue;
        }
        if (rtn_val[2] > BPRS[3])
          continue;
        c_key = 0;
        bone_key = 1;
        change = 0;
        Hbond_pair(i, j, seidx, AtomName, bseq, xyz, change, &nh, hb_atom1,
                   hb_atom2, hb_dist, c_key, bone_key);
        if (nh > 0) {
          nc1 = 0;
          nc2 = 0;
          for (k = 1; k <= nh; k++) {
            if (((!strcmp(hb_atom1[k], " O2'") ||
                  !strcmp(hb_atom1[k], " O4'")) &&
                 strchr("NO", hb_atom2[k][1]) && hb_atom2[k][3] != '\'' &&
                 hb_atom2[k][3] != 'P') ||
                ((!strcmp(hb_atom2[k], " O2'") ||
                  !strcmp(hb_atom2[k], " O4'")) &&
                 strchr("NO", hb_atom1[k][1]) && hb_atom1[k][3] != '\'' &&
                 hb_atom1[k][3] != 'P')) {
              nc1++;
            } else if (((!strcmp(hb_atom1[k], " O1P") ||
                         !strcmp(hb_atom1[k], " O2P")) &&
                        hb_atom2[k][3] != '\'' && hb_atom2[k][1] != 'C') ||
                       ((!strcmp(hb_atom2[k], " O1P") ||
                         !strcmp(hb_atom2[k], " O2P")) &&
                        hb_atom1[k][3] != '\'' && hb_atom1[k][1] != 'C')) {
              nc2++;
            }
          }
          if (nh == nc1) {
            if (nb_sugar++ > num_residue - 2) {
              return 0;
            }
            geo_check = 4.8;
            LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                         hb_atom1, hb_atom2, hb_dist, type);
            if (strstr(tmp_str, ".") || strstr(tmp_str, "?")) {
              geo_check = 5.8;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
            }
            sprintf(base_sugar[nb_sugar],
                    "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !(b_s)\n", work_num,
                    ChainID[ir], ResSeq[ir], bseq[i], bseq[j], ResSeq[jr],
                    ChainID[jr], type, pa_int, syn_i, syn_j);
          } else if (nh == nc2) {
            if (nb_p++ > num_residue - 2) {
              return 0;
            }
            geo_check = 4.8;
            LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                         hb_atom1, hb_atom2, hb_dist, type);
            if (strstr(tmp_str, ".") || strstr(tmp_str, "?")) {
              geo_check = 5.8;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
            }
            sprintf(base_p[nb_p],
                    "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !b_(O1P,O2P)\n",
                    work_num, ChainID[ir], ResSeq[ir], bseq[i], bseq[j],
                    ResSeq[jr], ChainID[jr], type, pa_int, syn_i, syn_j);
          } else {
            if (nb_other++ > num_residue - 2) {
              return 0;
            }
            geo_check = 5.2;
            LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                         hb_atom1, hb_atom2, hb_dist, type);
            if (strstr(tmp_str, ".") || strstr(tmp_str, "?")) {
              geo_check = 6.0;
              LW_pair_type(i, j, geo_check, seidx, AtomName, HB_ATOM, xyz, bseq,
                           hb_atom1, hb_atom2, hb_dist, type);
            }
            sprintf(other[nb_other],
                    "%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !(s_s)\n", work_num,
                    ChainID[ir], ResSeq[ir], bseq[i], bseq[j], ResSeq[jr],
                    ChainID[jr], type, pa_int, syn_i, syn_j);
          }
        }
      }
    }
  }
  *num_pair_tot = num_bp;
  bp_network(num_residue, RY, seidx, AtomName, ResName, ChainID, ResSeq, Miscs,
             xyz, bseq, pair_info, Nxyz, orien, org, BPRS, num_multi, multi_idx,
             multi);
  free_cmatrix(base_single, 0, num_residue, 0, 120);
  free_cmatrix(base_sugar, 0, num_residue, 0, 120);
  free_cmatrix(base_p, 0, num_residue, 0, 120);
  free_cmatrix(other, 0, num_residue, 0, 120);
  free_cmatrix(hb_atom1, 0, 512, 0, 4);
  free_cmatrix(hb_atom2, 0, 512, 0, 4);
  free_dvector(hb_dist, 0, 512);
  free_lmatrix(pair_info, 0, num_residue, 0, 101L);
  free_lvector(prot_rna, 0, num_residue);
  return profile;
}


x86 assembly (clang, -O0):
<all_pairs>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa28,%rsp
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
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,-0x38(%rbp)
mov    %rsi,-0x40(%rbp)
mov    %rdx,-0x48(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    %r9,-0x60(%rbp)
movb   $0x20,-0x261(%rbp)
movq   $0x0,-0x838(%rbp)
movq   $0x0,-0x840(%rbp)
movq   $0x0,-0x848(%rbp)
movq   $0x0,-0x850(%rbp)
movq   $0x0,-0x868(%rbp)
movq   $0x0,-0x898(%rbp)
movq   $0x0,-0x8a8(%rbp)
movq   $0x0,-0x8d0(%rbp)
movq   $0x0,-0x8d8(%rbp)
movq   $0x0,-0x8e0(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
shl    $0x0,%rax
mov    %eax,%edi
call   10e0 <malloc@plt>
mov    %rax,-0x9c0(%rbp)
movq   $0x0,-0x870(%rbp)
mov    -0x870(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    13e4 <all_pairs+0x154>
mov    -0x9c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
movb   $0x2e,(%rax,%rcx,1)
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x870(%rbp)
jmp    13aa <all_pairs+0x11a>
mov    -0x9c0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
mov    $0x78,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x818(%rbp)
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
mov    $0x78,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x820(%rbp)
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
mov    $0x78,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x828(%rbp)
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
mov    $0x78,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x830(%rbp)
xor    %edx,%edx
mov    $0x200,%esi
mov    $0x4,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x6b0(%rbp)
xor    %edx,%edx
mov    $0x200,%esi
mov    $0x4,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x6b8(%rbp)
xor    %edi,%edi
mov    $0x200,%esi
call   10f0 <dvector@plt>
mov    %rax,-0x9a8(%rbp)
lea    -0x9a0(%rbp),%rdi
lea    -0x260(%rbp),%rsi
lea    -0x480(%rbp),%rdx
call   10b0 <hb_crt_alt@plt>
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
mov    $0x65,%ecx
mov    %edx,%edi
call   1120 <lmatrix@plt>
mov    %rax,-0x8c0(%rbp)
mov    -0x40(%rbp),%rsi
xor    %edi,%edi
call   1180 <lvector@plt>
mov    %rax,-0x8c8(%rbp)
movq   $0x0,-0x870(%rbp)
mov    -0x870(%rbp),%rax
cmp    -0x40(%rbp),%rax
jg     156c <all_pairs+0x2dc>
movq   $0x0,-0x880(%rbp)
cmpq   $0x65,-0x880(%rbp)
65
jg     1550 <all_pairs+0x2c0>
mov    -0x8c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x880(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x880(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x880(%rbp)
jmp    150a <all_pairs+0x27a>
jmp    1555 <all_pairs+0x2c5>
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x870(%rbp)
jmp    14ee <all_pairs+0x25e>
movq   $0x0,-0x870(%rbp)
cmpq   $0x200,-0x870(%rbp)
jge    15f1 <all_pairs+0x361>
mov    -0x6b0(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2bf6(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x6b8(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x2bd8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x9a8(%rbp),%rax
mov    -0x870(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x870(%rbp)
jmp    1577 <all_pairs+0x2e7>
movq   $0x1,-0x870(%rbp)
mov    -0x870(%rbp),%rax
cmp    -0x40(%rbp),%rax
jg     1650 <all_pairs+0x3c0>
mov    -0x8c8(%rbp),%rax
mov    -0x870(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    0x98(%rbp),%rax
mov    -0x870(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x870(%rbp)
jmp    15fc <all_pairs+0x36c>
mov    -0x40(%rbp),%rdi
mov    0x28(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x20(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    0x98(%rbp),%r9
call   1110 <syn_or_anti@plt>
movq   $0x1,-0x870(%rbp)
mov    -0x870(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    31ac <all_pairs+0x1f1c>
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x880(%rbp)
mov    -0x880(%rbp),%rax
cmp    -0x40(%rbp),%rax
jg     3190 <all_pairs+0x1f00>
mov    0x18(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x878(%rbp)
mov    0x18(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x888(%rbp)
mov    0x98(%rbp),%rax
mov    -0x870(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    171d <all_pairs+0x48d>
lea    -0x6f0(%rbp),%rdi
lea    0x296e(%rip),%rsi
lea    0x296c(%rip),%rdx
mov    $0x0,%al
call   1170 <sprintf@plt>
jmp    1730 <all_pairs+0x4a0>
lea    -0x6f0(%rbp),%rdi
lea    0x2956(%rip),%rsi
call   1030 <strcpy@plt>
mov    0x98(%rbp),%rax
mov    -0x880(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jne    176a <all_pairs+0x4da>
lea    -0x710(%rbp),%rdi
lea    0x2921(%rip),%rsi
lea    0x291f(%rip),%rdx
mov    $0x0,%al
call   1170 <sprintf@plt>
jmp    177d <all_pairs+0x4ed>
lea    -0x710(%rbp),%rdi
lea    0x2909(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
mov    0x50(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r15
mov    -0x60(%rbp),%r14
mov    0x28(%rbp),%rbx
mov    0x10(%rbp),%r11
lea    -0x990(%rbp),%r10
lea    -0x868(%rbp),%rax
xor    %r12d,%r12d
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
movl   $0x0,0x30(%rsp)
call   1060 <check_pairs@plt>
cmpq   $0x0,-0x868(%rbp)
je     25a8 <all_pairs+0x1318>
mov    0x18(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x878(%rbp)
mov    0x18(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x888(%rbp)
lea    -0x6a0(%rbp),%rdi
mov    -0x870(%rbp),%rdx
mov    -0x880(%rbp),%rcx
lea    0x2840(%rip),%rsi
mov    $0x0,%al
call   1170 <sprintf@plt>
movsd  0x27dd(%rip),%xmm0
movsd  %xmm0,-0x9b0(%rbp)
ff
movq   $0x1,-0x8b0(%rbp)
movq   $0x0,-0x8b8(%rbp)
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x20(%rbp),%r9
movsd  -0x9b0(%rbp),%xmm0
ff
mov    -0x6b0(%rbp),%r14
mov    -0x6b8(%rbp),%rbx
mov    -0x9a8(%rbp),%r11
mov    -0x8b0(%rbp),%r10
mov    -0x8b8(%rbp),%rax
lea    -0x8a0(%rbp),%r15
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1160 <Hbond_pair@plt>
movq   $0x0,-0x8e0(%rbp)
movq   $0x1,-0x890(%rbp)
mov    -0x890(%rbp),%rax
cmp    -0x8a0(%rbp),%rax
jg     1979 <all_pairs+0x6e9>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x20,%eax
je     1950 <all_pairs+0x6c0>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x20,%eax
je     1950 <all_pairs+0x6c0>
jmp    1962 <all_pairs+0x6d2>
mov    -0x8e0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8e0(%rbp)
mov    -0x890(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x890(%rbp)
jmp    18f9 <all_pairs+0x669>
cmpq   $0x1,-0x8e0(%rbp)
01
jne    1b0b <all_pairs+0x87b>
mov    -0x838(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x838(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    19ba <all_pairs+0x72a>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x2646(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x810(%rbp),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
ff
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x25cb(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
mov    -0x818(%rbp),%rax
mov    -0x838(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x810(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    3179 <all_pairs+0x1ee9>
mov    -0x8a0(%rbp),%rsi
xor    %edx,%edx
mov    $0x4,%ecx
mov    %edx,%edi
call   1070 <cmatrix@plt>
mov    %rax,-0x688(%rbp)
mov    -0x8a0(%rbp),%rdi
mov    -0x6b0(%rbp),%rsi
mov    -0x688(%rbp),%rcx
lea    -0x8d0(%rbp),%rdx
call   11b0 <get_unequility@plt>
mov    -0x8a0(%rbp),%rdi
mov    -0x6b8(%rbp),%rsi
mov    -0x688(%rbp),%rcx
lea    -0x8d8(%rbp),%rdx
call   11b0 <get_unequility@plt>
mov    -0x688(%rbp),%rdi
mov    -0x8a0(%rbp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
cmpq   $0x1,-0x8d0(%rbp)
01
jne    1ba4 <all_pairs+0x914>
cmpq   $0x1,-0x8d8(%rbp)
01
jg     1bc0 <all_pairs+0x930>
cmpq   $0x1,-0x8d8(%rbp)
01
jne    2044 <all_pairs+0xdb4>
cmpq   $0x1,-0x8d0(%rbp)
01
jle    2044 <all_pairs+0xdb4>
movsd  -0x980(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  0x246f(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
ja     1c0e <all_pairs+0x97e>
movsd  -0x978(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  0x2450(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1d92 <all_pairs+0xb02>
mov    -0x838(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x838(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    1c41 <all_pairs+0x9b1>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x2427(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x810(%rbp),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
ff
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x2375(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
mov    -0x818(%rbp),%rax
mov    -0x838(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x810(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    3179 <all_pairs+0x1ee9>
movsd  0x22be(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x6a5(%rbp),%rdi
movsbl -0x6d0(%rbp),%edx
movsbl -0x6ce(%rbp),%ecx
movsbl -0x6cc(%rbp),%r8d
ff
lea    0x22c1(%rip),%rsi
mov    $0x0,%al
call   1170 <sprintf@plt>
lea    -0x6a5(%rbp),%rdi
lea    0x22b3(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    1ebb <all_pairs+0xc2b>
lea    -0x6a5(%rbp),%rdi
lea    0x2298(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    1ebb <all_pairs+0xc2b>
movsd  -0x980(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
movsd  0x21da(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
ja     1ebb <all_pairs+0xc2b>
movsd  -0x978(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  0x21bb(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    203f <all_pairs+0xdaf>
mov    -0x838(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x838(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    1eee <all_pairs+0xc5e>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x217a(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x810(%rbp),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
ff
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x20c8(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
mov    -0x818(%rbp),%rax
mov    -0x838(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x810(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    3179 <all_pairs+0x1ee9>
jmp    235b <all_pairs+0x10cb>
cmpq   $0x2,-0x868(%rbp)
02
jne    21df <all_pairs+0xf4f>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
jne    20b2 <all_pairs+0xe22>
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     2112 <all_pairs+0xe82>
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
je     2112 <all_pairs+0xe82>
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x41,%eax
jne    212a <all_pairs+0xe9a>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x55,%eax
je     2112 <all_pairs+0xe82>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x54,%eax
jne    212a <all_pairs+0xe9a>
lea    -0x6d0(%rbp),%rdi
lea    0x1fd8(%rip),%rsi
call   1030 <strcpy@plt>
jmp    21da <all_pairs+0xf4a>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    216a <all_pairs+0xeda>
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
je     21aa <all_pairs+0xf1a>
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x47,%eax
jne    21c2 <all_pairs+0xf32>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <toupper@plt>
movsbl %al,%eax
cmp    $0x43,%eax
jne    21c2 <all_pairs+0xf32>
lea    -0x6d0(%rbp),%rdi
lea    0x1f49(%rip),%rsi
call   1030 <strcpy@plt>
jmp    21d5 <all_pairs+0xf45>
lea    -0x6d0(%rbp),%rdi
lea    0x1f3a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    21da <all_pairs+0xf4a>
jmp    2356 <all_pairs+0x10c6>
cmpq   $0x1,-0x868(%rbp)
01
je     21fb <all_pairs+0xf6b>
cmpq   $0xffffffffffffffff,-0x868(%rbp)
ff
jne    2351 <all_pairs+0x10c1>
movsd  0x1e35(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x6a5(%rbp),%rdi
movsbl -0x6d0(%rbp),%edx
movsbl -0x6ce(%rbp),%ecx
movsbl -0x6cc(%rbp),%r8d
ff
lea    0x1e58(%rip),%rsi
mov    $0x0,%al
call   1170 <sprintf@plt>
lea    -0x6a5(%rbp),%rdi
lea    0x1e4a(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    22d6 <all_pairs+0x1046>
lea    -0x6a5(%rbp),%rdi
lea    0x1e2f(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
je     234c <all_pairs+0x10bc>
movsd  0x1d62(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
jmp    2351 <all_pairs+0x10c1>
jmp    2356 <all_pairs+0x10c6>
jmp    235b <all_pairs+0x10cb>
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,1),%sil
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,1),%al
lea    -0x6d0(%rbp),%rdx
lea    -0x280(%rbp),%rcx
movsbl %sil,%edi
movsbl %al,%esi
call   1130 <LW_Saenger_correspond@plt>
lea    -0x6d0(%rbp),%rdi
call   1050 <ConvertState@plt>
mov    %al,%dl
mov    -0x9c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
sub    $0x1,%rcx
mov    %dl,(%rax,%rcx,1)
lea    -0x6d0(%rbp),%rdi
call   1050 <ConvertState@plt>
mov    %al,%dl
mov    -0x9c0(%rbp),%rax
mov    -0x880(%rbp),%rcx
sub    $0x1,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x898(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x898(%rbp)
lea    -0x6a5(%rbp),%rdi
movsbl -0x6d0(%rbp),%edx
movsbl -0x6ce(%rbp),%ecx
movsbl -0x6cc(%rbp),%r8d
ff
lea    0x1cdf(%rip),%rsi
mov    $0x0,%al
call   1170 <sprintf@plt>
mov    0x60(%rbp),%rax
mov    -0x898(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x6a5(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x898(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jl     2455 <all_pairs+0x11c5>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
mov    -0x870(%rbp),%rcx
mov    0x68(%rbp),%rax
mov    -0x898(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,0x8(%rax)
mov    -0x880(%rbp),%rcx
mov    0x68(%rbp),%rax
mov    -0x898(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,0x10(%rax)
mov    -0x8c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x328(%rcx),%rax
add    $0x1,%rax
mov    %rax,0x328(%rcx)
cmp    $0x65,%rax
jl     24e0 <all_pairs+0x1250>
mov    -0x8c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x328(%rax),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x328(%rax)
jmp    3190 <all_pairs+0x1f00>
mov    -0x880(%rbp),%rdx
mov    -0x8c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8c0(%rbp),%rcx
mov    -0x870(%rbp),%rsi
mov    (%rcx,%rsi,8),%rcx
mov    0x328(%rcx),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8c0(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x328(%rcx),%rax
add    $0x1,%rax
mov    %rax,0x328(%rcx)
cmp    $0x65,%rax
jl     256d <all_pairs+0x12dd>
mov    -0x8c0(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x328(%rax),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x328(%rax)
jmp    3190 <all_pairs+0x1f00>
mov    -0x870(%rbp),%rdx
mov    -0x8c0(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8c0(%rbp),%rcx
mov    -0x880(%rbp),%rsi
mov    (%rcx,%rsi,8),%rcx
mov    0x328(%rcx),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    3174 <all_pairs+0x1ee4>
cmpq   $0x0,-0x868(%rbp)
jne    316f <all_pairs+0x1edf>
mov    0x18(%rbp),%rax
mov    -0x870(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x878(%rbp)
mov    0x18(%rbp),%rax
mov    -0x880(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x888(%rbp)
lea    -0x6a0(%rbp),%rdi
mov    -0x870(%rbp),%rdx
mov    -0x880(%rbp),%rcx
lea    0x1a7e(%rip),%rsi
mov    $0x0,%al
call   1170 <sprintf@plt>
movsd  -0x988(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
ucomisd 0x10(%rax),%xmm0
jbe    2629 <all_pairs+0x1399>
jmp    3179 <all_pairs+0x1ee9>
movsd  -0x980(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movsd  0x19c3(%rip),%xmm1
addsd  0x18(%rax),%xmm1
ucomisd %xmm1,%xmm0
jbe    2651 <all_pairs+0x13c1>
jmp    3179 <all_pairs+0x1ee9>
movsd  -0x978(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
ucomisd 0x20(%rax),%xmm0
jbe    266d <all_pairs+0x13dd>
jmp    3179 <all_pairs+0x1ee9>
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
mov    0x50(%rbp),%rdx
mov    0x18(%rbp),%rcx
mov    0x28(%rbp),%r8
mov    0x20(%rbp),%r9
lea    -0x990(%rbp),%r10
lea    -0x8a8(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1090 <base_stack@plt>
cmpq   $0x0,-0x8a8(%rbp)
jle    2716 <all_pairs+0x1486>
movsd  0x196b(%rip),%xmm0
ucomisd -0x978(%rbp),%xmm0
ff
jbe    2711 <all_pairs+0x1481>
lea    0x1a41(%rip),%rdi
call   1050 <ConvertState@plt>
mov    %al,%dl
mov    -0x9c0(%rbp),%rax
mov    -0x870(%rbp),%rcx
sub    $0x1,%rcx
mov    %dl,(%rax,%rcx,1)
lea    0x1a1e(%rip),%rdi
call   1050 <ConvertState@plt>
mov    %al,%dl
mov    -0x9c0(%rbp),%rax
mov    -0x880(%rbp),%rcx
sub    $0x1,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    3179 <all_pairs+0x1ee9>
movsd  -0x980(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
ucomisd 0x18(%rax),%xmm0
jbe    2732 <all_pairs+0x14a2>
jmp    3179 <all_pairs+0x1ee9>
movq   $0x0,-0x8b0(%rbp)
movq   $0x1,-0x8b8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x9b0(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x50(%rbp),%r8
mov    0x20(%rbp),%r9
movsd  -0x9b0(%rbp),%xmm0
ff
mov    -0x6b0(%rbp),%r14
mov    -0x6b8(%rbp),%rbx
mov    -0x9a8(%rbp),%r11
mov    -0x8b0(%rbp),%r10
mov    -0x8b8(%rbp),%rax
lea    -0x8a0(%rbp),%r15
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1160 <Hbond_pair@plt>
cmpq   $0x0,-0x8a0(%rbp)
jle    316a <all_pairs+0x1eda>
movq   $0x0,-0x858(%rbp)
movq   $0x0,-0x860(%rbp)
movq   $0x1,-0x890(%rbp)
mov    -0x890(%rbp),%rax
cmp    -0x8a0(%rbp),%rax
jg     2ada <all_pairs+0x184a>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x18fc(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     2856 <all_pairs+0x15c6>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x18da(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    28c0 <all_pairs+0x1630>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x18b8(%rip),%rdi
movsbl 0x1(%rax),%esi
call   10a0 <strchr@plt>
cmp    $0x0,%rax
je     28c0 <all_pairs+0x1630>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     28c0 <all_pairs+0x1630>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
jne    2978 <all_pairs+0x16e8>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1844(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     290e <all_pairs+0x167e>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1822(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    298f <all_pairs+0x16ff>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
lea    0x1800(%rip),%rdi
movsbl 0x1(%rax),%esi
call   10a0 <strchr@plt>
cmp    $0x0,%rax
je     298f <all_pairs+0x16ff>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     298f <all_pairs+0x16ff>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x50,%eax
je     298f <all_pairs+0x16ff>
mov    -0x858(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x858(%rbp)
jmp    2abe <all_pairs+0x182e>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1782(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     29dd <all_pairs+0x174d>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1760(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    2a1b <all_pairs+0x178b>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     2a1b <all_pairs+0x178b>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
jne    2aa7 <all_pairs+0x1817>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x16f6(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
je     2a69 <all_pairs+0x17d9>
mov    -0x6b8(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x16d4(%rip),%rsi
call   10c0 <strcmp@plt>
cmp    $0x0,%eax
jne    2ab9 <all_pairs+0x1829>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x3(%rax),%eax
cmp    $0x27,%eax
je     2ab9 <all_pairs+0x1829>
mov    -0x6b0(%rbp),%rax
mov    -0x890(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x43,%eax
je     2ab9 <all_pairs+0x1829>
mov    -0x860(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x860(%rbp)
jmp    2abe <all_pairs+0x182e>
jmp    2ac3 <all_pairs+0x1833>
mov    -0x890(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x890(%rbp)
jmp    27f4 <all_pairs+0x1564>
mov    -0x8a0(%rbp),%rax
cmp    -0x858(%rbp),%rax
jne    2d0f <all_pairs+0x1a7f>
mov    -0x840(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x840(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    2b21 <all_pairs+0x1891>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x14ef(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x6a5(%rbp),%rdi
lea    0x154f(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    2bd1 <all_pairs+0x1941>
lea    -0x6a5(%rbp),%rdi
lea    0x1534(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
je     2c47 <all_pairs+0x19b7>
movsd  0x1447(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
mov    -0x820(%rbp),%rax
mov    -0x840(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
ff
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x1453(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
jmp    3165 <all_pairs+0x1ed5>
mov    -0x8a0(%rbp),%rax
cmp    -0x860(%rbp),%rax
jne    2f44 <all_pairs+0x1cb4>
mov    -0x848(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x848(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    2d56 <all_pairs+0x1ac6>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x12ba(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x6a5(%rbp),%rdi
lea    0x131a(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    2e06 <all_pairs+0x1b76>
lea    -0x6a5(%rbp),%rdi
lea    0x12ff(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
je     2e7c <all_pairs+0x1bec>
movsd  0x1212(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
mov    -0x828(%rbp),%rax
mov    -0x848(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x124d(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
jmp    3160 <all_pairs+0x1ed0>
mov    -0x850(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x850(%rbp)
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jle    2f77 <all_pairs+0x1ce7>
movq   $0x0,-0x30(%rbp)
jmp    3384 <all_pairs+0x20f4>
movsd  0x1089(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
lea    -0x6a5(%rbp),%rdi
lea    0x10f9(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
jne    3027 <all_pairs+0x1d97>
lea    -0x6a5(%rbp),%rdi
lea    0x10de(%rip),%rsi
call   11a0 <strstr@plt>
cmp    $0x0,%rax
je     309d <all_pairs+0x1e0d>
movsd  0xfe1(%rip),%xmm0
movsd  %xmm0,-0x9b8(%rbp)
ff
mov    -0x870(%rbp),%rdi
mov    -0x880(%rbp),%rsi
movsd  -0x9b8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
lea    -0x260(%rbp),%r8
mov    0x20(%rbp),%r9
mov    0x50(%rbp),%r14
mov    -0x6b0(%rbp),%rbx
mov    -0x6b8(%rbp),%r11
mov    -0x9a8(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1150 <LW_pair_type@plt>
mov    -0x830(%rbp),%rax
mov    -0x850(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x6a0(%rbp),%rdx
mov    0x38(%rbp),%rax
mov    -0x878(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    0x40(%rbp),%rax
mov    -0x878(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    0x50(%rbp),%rax
mov    -0x870(%rbp),%rsi
movsbl (%rax,%rsi,1),%r9d
mov    0x50(%rbp),%rax
mov    -0x880(%rbp),%rsi
movsbl (%rax,%rsi,1),%r12d
mov    0x40(%rbp),%rax
mov    -0x888(%rbp),%rsi
mov    (%rax,%rsi,8),%r15
mov    0x38(%rbp),%rax
mov    -0x888(%rbp),%rsi
movsbl (%rax,%rsi,1),%r14d
lea    -0x6d0(%rbp),%rbx
movsbl -0x261(%rbp),%r11d
ff
lea    -0x6f0(%rbp),%r10
lea    -0x710(%rbp),%rax
lea    0x1061(%rip),%rsi
mov    %r12d,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
mov    $0x0,%al
call   1170 <sprintf@plt>
jmp    3165 <all_pairs+0x1ed5>
jmp    316a <all_pairs+0x1eda>
jmp    316f <all_pairs+0x1edf>
jmp    3174 <all_pairs+0x1ee4>
jmp    3179 <all_pairs+0x1ee9>
mov    -0x880(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x880(%rbp)
jmp    169e <all_pairs+0x40e>
jmp    3195 <all_pairs+0x1f05>
mov    -0x870(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x870(%rbp)
jmp    167b <all_pairs+0x3eb>
mov    -0x898(%rbp),%rcx
mov    0x58(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    0x30(%rbp),%r8
mov    0x38(%rbp),%r9
mov    0x40(%rbp),%rax
mov    %rax,-0x9e8(%rbp)
mov    0x48(%rbp),%rax
mov    %rax,-0x9e0(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x9d8(%rbp)
mov    0x50(%rbp),%rax
mov    %rax,-0x9d0(%rbp)
mov    -0x8c0(%rbp),%r13
mov    -0x50(%rbp),%r12
mov    -0x58(%rbp),%r15
mov    -0x60(%rbp),%r14
mov    0x10(%rbp),%rbx
mov    0x80(%rbp),%r11
mov    0x88(%rbp),%r10
mov    0x90(%rbp),%rax
mov    %rax,-0x9c8(%rbp)
mov    -0x9e8(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x9e0(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x9d8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x9d0(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x9c8(%rbp),%rax
mov    %r13,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
call   10d0 <bp_network@plt>
mov    -0x818(%rbp),%rdi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x820(%rbp),%rdi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x828(%rbp),%rdi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x830(%rbp),%rdi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x6b0(%rbp),%rdi
xor    %ecx,%ecx
mov    $0x200,%edx
mov    $0x4,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x6b8(%rbp),%rdi
xor    %ecx,%ecx
mov    $0x200,%edx
mov    $0x4,%r8d
mov    %ecx,%esi
call   1100 <free_cmatrix@plt>
mov    -0x9a8(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1140 <free_dvector@plt>
mov    -0x8c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
xor    %ecx,%ecx
mov    $0x65,%r8d
mov    %ecx,%esi
call   1190 <free_lmatrix@plt>
mov    -0x8c8(%rbp),%rdi
mov    -0x40(%rbp),%rdx
xor    %esi,%esi
call   1080 <free_lvector@plt>
mov    -0x9c0(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0xa28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<all_pairs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x778,%rsp
mov    %r9,0x130(%rsp)
mov    %r8,0x138(%rsp)
mov    %rcx,0x140(%rsp)
mov    %rdx,0x90(%rsp)
mov    %rsi,%rbp
movq   $0x0,0xc8(%rsp)
movq   $0x0,0x158(%rsp)
movq   $0x0,0x150(%rsp)
movq   $0x0,0x148(%rsp)
lea    0x1(%rsi),%edi
call   10f0 <malloc@plt>
mov    %rax,%rbx
test   %rbp,%rbp
jle    1324 <all_pairs+0x84>
mov    %rbx,%rdi
mov    $0x2e,%esi
mov    %rbp,%rdx
call   10b0 <memset@plt>
mov    %rbx,0xc0(%rsp)
movb   $0x0,(%rbx,%rbp,1)
xor    %edi,%edi
mov    %rbp,%rsi
xor    %edx,%edx
mov    $0x78,%ecx
call   1070 <cmatrix@plt>
mov    %rax,0xa0(%rsp)
xor    %edi,%edi
mov    %rbp,%rsi
xor    %edx,%edx
mov    $0x78,%ecx
call   1070 <cmatrix@plt>
mov    %rax,0x120(%rsp)
xor    %edi,%edi
mov    %rbp,%rsi
xor    %edx,%edx
mov    $0x78,%ecx
call   1070 <cmatrix@plt>
mov    %rax,0x118(%rsp)
xor    %edi,%edi
mov    %rbp,%rsi
xor    %edx,%edx
mov    $0x78,%ecx
call   1070 <cmatrix@plt>
mov    %rax,0x110(%rsp)
mov    $0x200,%esi
xor    %edi,%edi
xor    %edx,%edx
mov    $0x4,%ecx
call   1070 <cmatrix@plt>
mov    %rax,%r14
mov    $0x200,%esi
xor    %edi,%edi
xor    %edx,%edx
mov    $0x4,%ecx
call   1070 <cmatrix@plt>
mov    %rax,%r15
xor    %edi,%edi
mov    $0x200,%esi
call   1100 <dvector@plt>
mov    %rax,0x20(%rsp)
lea    0x240(%rsp),%rdi
lea    0x270(%rsp),%rsi
lea    0x570(%rsp),%rdx
call   10c0 <hb_crt_alt@plt>
mov    $0x65,%ecx
xor    %edi,%edi
mov    %rbp,%rsi
xor    %edx,%edx
call   1130 <lmatrix@plt>
mov    %rax,0x98(%rsp)
xor    %edi,%edi
mov    %rbp,%rsi
call   1190 <lvector@plt>
mov    %rax,%r13
mov    %rbp,0x8(%rsp)
test   %rbp,%rbp
mov    %rax,0x128(%rsp)
js     1529 <all_pairs+0x289>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rbx
mov    %ebx,%r12d
and    $0x7,%r12d
cmp    $0x7,%rax
jae    1447 <all_pairs+0x1a7>
xor    %ebp,%ebp
jmp    14f5 <all_pairs+0x255>
and    $0xfffffffffffffff8,%rbx
xor    %ebp,%ebp
mov    0x98(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x8(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x10(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x18(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x20(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x28(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x30(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    0x38(%r13,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    1460 <all_pairs+0x1c0>
test   %r12,%r12
mov    0x128(%rsp),%r13
je     1529 <all_pairs+0x289>
mov    0x98(%rsp),%rax
lea    (%rax,%rbp,8),%rbx
xor    %ebp,%ebp
mov    (%rbx,%rbp,8),%rdi
mov    $0x330,%edx
xor    %esi,%esi
call   10b0 <memset@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1510 <all_pairs+0x270>
xor    %ebp,%ebp
lea    0x1c65(%rip),%r12
mov    0x20(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbp,8),%rdi
mov    %r12,%rsi
call   1030 <strcpy@plt>
mov    (%r15,%rbp,8),%rdi
mov    %r12,%rsi
call   1030 <strcpy@plt>
movq   $0x0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    $0x200,%rbp
jne    1540 <all_pairs+0x2a0>
mov    0x8(%rsp),%rdi
test   %rdi,%rdi
jle    15fb <all_pairs+0x35b>
mov    $0x1,%eax
cmp    $0x4,%rdi
mov    0x7c0(%rsp),%rbp
mov    0x7b0(%rsp),%r12
mov    0x838(%rsp),%r9
mov    0x90(%rsp),%r8
jb     171e <all_pairs+0x47e>
lea    0x8(%r13),%rcx
lea    (%r9,%rdi,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rcx
jae    15d3 <all_pairs+0x333>
lea    0x8(,%rdi,8),%rcx
add    %r13,%rcx
lea    0x8(%r9),%rdx
cmp    %rcx,%rdx
jb     171e <all_pairs+0x47e>
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdx
jae    1643 <all_pairs+0x3a3>
xor    %edx,%edx
jmp    16ca <all_pairs+0x42a>
mov    %rdi,%rbx
mov    0x7c8(%rsp),%rsi
mov    0x7b8(%rsp),%rdx
mov    0x7c0(%rsp),%rcx
mov    0x90(%rsp),%rbp
mov    %rbp,%r8
mov    0x838(%rsp),%r9
call   1120 <syn_or_anti@plt>
mov    %rbp,%rsi
mov    %rbx,%rdi
xor    %ebp,%ebp
mov    0x7b0(%rsp),%r8
jmp    186b <all_pairs+0x5cb>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xorpd  %xmm0,%xmm0
nopl   (%rax)
movupd %xmm0,0x8(%r13,%rdx,8)
movupd %xmm0,0x18(%r13,%rdx,8)
movupd %xmm0,0x8(%r9,%rdx,8)
movupd %xmm0,0x18(%r9,%rdx,8)
movupd %xmm0,0x28(%r13,%rdx,8)
movupd %xmm0,0x38(%r13,%rdx,8)
movupd %xmm0,0x28(%r9,%rdx,8)
movupd %xmm0,0x38(%r9,%rdx,8)
movupd %xmm0,0x48(%r13,%rdx,8)
movupd %xmm0,0x58(%r13,%rdx,8)
movupd %xmm0,0x48(%r9,%rdx,8)
movupd %xmm0,0x58(%r9,%rdx,8)
movupd %xmm0,0x68(%r13,%rdx,8)
movupd %xmm0,0x78(%r13,%rdx,8)
movupd %xmm0,0x68(%r9,%rdx,8)
movupd %xmm0,0x78(%r9,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1650 <all_pairs+0x3b0>
test   %rcx,%rcx
je     1711 <all_pairs+0x471>
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rdx,8),%rsi
or     $0x8,%rsi
movupd %xmm0,0x0(%r13,%rsi,1)
movupd %xmm0,0x10(%r13,%rsi,1)
movupd %xmm0,(%r9,%rsi,1)
movupd %xmm0,0x10(%r9,%rsi,1)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rcx
jne    16e0 <all_pairs+0x440>
cmp    %rdi,%rax
je     17df <all_pairs+0x53f>
or     $0x1,%rax
mov    %edi,%edx
sub    %eax,%edx
add    $0x1,%edx
mov    %rdi,%rcx
sub    %rax,%rcx
and    $0x3,%rdx
je     175b <all_pairs+0x4bb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,0x0(%r13,%rax,8)
movq   $0x0,(%r9,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1740 <all_pairs+0x4a0>
cmp    $0x3,%rcx
jb     17df <all_pairs+0x53f>
mov    %rdi,%rcx
sub    %rax,%rcx
lea    (%r9,%rax,8),%rdx
add    $0x18,%rdx
lea    0x18(,%rax,8),%rax
add    %r13,%rax
mov    $0xffffffffffffffff,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,-0x10(%rax,%rsi,8)
movq   $0x0,-0x10(%rdx,%rsi,8)
movq   $0x0,-0x8(%rax,%rsi,8)
movq   $0x0,-0x8(%rdx,%rsi,8)
movq   $0x0,(%rax,%rsi,8)
movq   $0x0,(%rdx,%rsi,8)
movq   $0x0,0x8(%rax,%rsi,8)
movq   $0x0,0x8(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1790 <all_pairs+0x4f0>
mov    %r12,%rbx
mov    %rdi,%r12
mov    0x7c8(%rsp),%rsi
mov    0x7b8(%rsp),%rdx
mov    %rbp,%rcx
call   1120 <syn_or_anti@plt>
mov    %r12,%rdi
cmp    $0x2,%r12
jl     185e <all_pairs+0x5be>
lea    (%rdi,%rdi,1),%rax
mov    %rax,0x188(%rsp)
lea    -0x2(%rdi),%rax
mov    %rax,0x70(%rsp)
mov    $0x1,%eax
xor    %ecx,%ecx
mov    %rcx,0x38(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xb8(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xb0(%rsp)
xor    %ebp,%ebp
xor    %ecx,%ecx
mov    %rcx,0xa8(%rsp)
mov    %r15,0x78(%rsp)
mov    %r14,0x58(%rsp)
mov    0x838(%rsp),%rdx
jmp    1a1b <all_pairs+0x77b>
xor    %ebp,%ebp
mov    %rbx,%r8
mov    0x90(%rsp),%rsi
mov    0x7f8(%rsp),%rax
mov    %rbp,(%rax)
mov    %rdi,%rbp
mov    0x7b8(%rsp),%rdx
mov    0x7c8(%rsp),%rcx
mov    %r8,%rax
mov    0x7d0(%rsp),%r8
mov    0x7d8(%rsp),%r9
push   0x830(%rsp)
push   0x830(%rsp)
push   0x830(%rsp)
push   %rax
push   0x150(%rsp)
push   0x160(%rsp)
push   0x170(%rsp)
mov    0xd0(%rsp),%rbx
push   %rbx
push   0x830(%rsp)
push   0x808(%rsp)
push   0x838(%rsp)
push   0x838(%rsp)
call   10e0 <bp_network@plt>
add    $0x60,%rsp
mov    0xa0(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
call   1110 <free_cmatrix@plt>
mov    0x120(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
call   1110 <free_cmatrix@plt>
mov    0x118(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
call   1110 <free_cmatrix@plt>
mov    0x110(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x78,%r8d
call   1110 <free_cmatrix@plt>
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x200,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
call   1110 <free_cmatrix@plt>
mov    %r15,%rdi
xor    %esi,%esi
mov    $0x200,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
call   1110 <free_cmatrix@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1150 <free_dvector@plt>
mov    $0x65,%r8d
mov    %rbx,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
xor    %ecx,%ecx
call   11a0 <free_lmatrix@plt>
mov    %r13,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <free_lvector@plt>
mov    0xc0(%rsp),%rax
jmp    2cd4 <all_pairs+0x1a34>
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
mov    %rcx,0x328(%rax)
mov    %r12,%rbp
mov    0x7b0(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
mov    0x180(%rsp),%rax
cmp    %rdi,%rax
mov    0x90(%rsp),%rsi
mov    0x128(%rsp),%r13
mov    0x78(%rsp),%r15
mov    0x58(%rsp),%r14
je     186b <all_pairs+0x5cb>
mov    %rax,%r13
lea    0x1(%rax),%rbx
mov    %rbx,0x180(%rsp)
mov    %rax,0x10(%rsp)
jmp    1b7f <all_pairs+0x8df>
mov    0x38(%rsp),%r15
cmp    0x70(%rsp),%r15
jg     2cd2 <all_pairs+0x1a32>
lea    0x1(%r15),%rax
mov    %rax,0x60(%rsp)
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    %rdi,%r12
mov    0x30(%rsp),%r14
mov    %r14,%rsi
movsd  0x159f(%rip),%xmm0
mov    %r15,0x40(%rsp)
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    0x7c8(%rsp),%r9
lea    0x48(%rsp),%r13
push   %r13
push   0x30(%rsp)
push   0x90(%rsp)
push   %rbx
push   %rbp
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r10
mov    (%r10,%rsi,8),%r8
movsbl 0x0(%rbp,%r12,1),%r9d
mov    %r12,%r15
movsbl 0x0(%rbp,%r14,1),%r11d
mov    0x88(%rsp),%r13
movsbl (%rdx,%r13,1),%ebx
sub    $0x8,%rsp
lea    0x478(%rsp),%r12
mov    %r12,%rdi
lea    0x158d(%rip),%rsi
lea    0x168(%rsp),%rdx
xor    %eax,%eax
lea    0xd8(%rsp),%rbp
push   %rbp
lea    0x100(%rsp),%rbp
push   %rbp
push   $0x20
lea    0x60(%rsp),%rbp
push   %rbp
push   %rbx
push   (%r10,%r13,8)
push   %r11
call   1180 <sprintf@plt>
add    $0x40,%rsp
mov    0xa0(%rsp),%rax
mov    0x38(%rsp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
mov    %r15,%r13
mov    %r12,%rsi
call   1030 <strcpy@plt>
mov    0x60(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x7b0(%rsp),%r8
mov    0x8(%rsp),%rdi
mov    0x838(%rsp),%rdx
mov    0x30(%rsp),%rbp
lea    0x1(%r14),%rbx
cmp    %rdi,%r14
jge    19f0 <all_pairs+0x750>
mov    %rbp,0x30(%rsp)
mov    %r13,%r12
cmpq   $0x1,(%rdx,%r13,8)
jne    1bb0 <all_pairs+0x910>
lea    0xf0(%rsp),%rdi
lea    0x14db(%rip),%rsi
lea    0x14d9(%rip),%rdx
xor    %eax,%eax
call   1180 <sprintf@plt>
jmp    1bc4 <all_pairs+0x924>
nopl   (%rax)
lea    0xf0(%rsp),%rdi
lea    0x14c2(%rip),%rsi
call   1030 <strcpy@plt>
mov    0x7c8(%rsp),%r13
mov    0x7c0(%rsp),%r15
mov    0x838(%rsp),%rax
cmpq   $0x1,(%rax,%rbx,8)
jne    1c10 <all_pairs+0x970>
lea    0xd0(%rsp),%rdi
lea    0x1486(%rip),%rsi
lea    0x1484(%rip),%rdx
xor    %eax,%eax
call   1180 <sprintf@plt>
jmp    1c24 <all_pairs+0x984>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0xd0(%rsp),%rdi
lea    0x1462(%rip),%rsi
call   1030 <strcpy@plt>
sub    $0x8,%rsp
mov    %r12,%rdi
mov    %rbx,%rsi
mov    0x7f8(%rsp),%rbp
mov    %rbp,%rdx
mov    0x7c0(%rsp),%r14
mov    %r14,%rcx
mov    %r15,%r8
mov    0x148(%rsp),%r9
push   $0x0
lea    0xd8(%rsp),%rax
push   %rax
lea    0x1a8(%rsp),%rax
push   %rax
push   0x7d0(%rsp)
push   %r13
push   0x160(%rsp)
push   0x170(%rsp)
call   1060 <check_pairs@plt>
add    $0x40,%rsp
mov    %r12,%r15
mov    0xc8(%rsp),%r12
mov    (%r14,%r15,8),%rax
mov    0x8(%rax),%rax
mov    %rax,0x80(%rsp)
mov    (%r14,%rbx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,0x88(%rsp)
lea    0x160(%rsp),%rdi
lea    0x13c7(%rip),%rsi
mov    %r15,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1180 <sprintf@plt>
test   %r12,%r12
je     1f60 <all_pairs+0xcc0>
mov    %r15,%rdi
mov    %rbx,0x28(%rsp)
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
mov    0x7c0(%rsp),%r9
movsd  0x1309(%rip),%xmm0
push   $0x0
push   $0x1
push   0x30(%rsp)
mov    0x90(%rsp),%r14
push   %r14
mov    0x78(%rsp),%rbx
push   %rbx
lea    0x90(%rsp),%rax
push   %rax
call   1170 <Hbond_pair@plt>
add    $0x30,%rsp
mov    0x68(%rsp),%rsi
test   %rsi,%rsi
mov    0x7b0(%rsp),%r15
jle    1d6c <all_pairs+0xacc>
cmp    $0x1,%rsi
jne    1f8e <all_pairs+0xcee>
mov    $0x1,%ecx
xor    %eax,%eax
test   $0x1,%sil
je     1d62 <all_pairs+0xac2>
mov    (%rbx,%rcx,8),%rdx
cmpb   $0x20,0x3(%rdx)
je     1d5e <all_pairs+0xabe>
mov    (%r14,%rcx,8),%rcx
cmpb   $0x20,0x3(%rcx)
jne    1d62 <all_pairs+0xac2>
add    $0x1,%rax
cmp    $0x1,%rax
je     1a34 <all_pairs+0x794>
mov    %rbp,%r12
xor    %edi,%edi
xor    %edx,%edx
mov    $0x4,%ecx
call   1070 <cmatrix@plt>
mov    %rax,%rbp
mov    0x68(%rsp),%rdi
mov    %rbx,%rsi
lea    0x150(%rsp),%rdx
mov    %rax,%rcx
call   11c0 <get_unequility@plt>
mov    0x68(%rsp),%rdi
mov    %r14,%rsi
lea    0x148(%rsp),%rdx
mov    %rbp,%rcx
call   11c0 <get_unequility@plt>
mov    0x68(%rsp),%edx
mov    %rbp,%rdi
xor    %esi,%esi
xor    %ecx,%ecx
mov    $0x4,%r8d
call   1110 <free_cmatrix@plt>
mov    0x150(%rsp),%rax
mov    0x148(%rsp),%rcx
cmp    $0x1,%rax
jne    1de2 <all_pairs+0xb42>
cmp    $0x1,%rcx
jg     1df6 <all_pairs+0xb56>
cmp    $0x1,%rcx
jne    206f <all_pairs+0xdcf>
cmp    $0x2,%rax
jl     206f <all_pairs+0xdcf>
movsd  0x1a0(%rsp),%xmm0
movsd  0x18(%r15),%xmm1
addsd  0x1213(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    0x7c0(%rsp),%r9
mov    0x7b8(%rsp),%r13
ja     1e44 <all_pairs+0xba4>
movsd  0x1a8(%rsp),%xmm0
movsd  0x20(%r15),%xmm1
addsd  0x11ee(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2130 <all_pairs+0xe90>
mov    0x38(%rsp),%r15
cmp    0x70(%rsp),%r15
lea    0x40(%rsp),%rax
jg     2cd2 <all_pairs+0x1a32>
mov    %r12,%rbp
lea    0x1(%r15),%rcx
mov    %rcx,0x60(%rsp)
sub    $0x8,%rsp
mov    0x18(%rsp),%r12
mov    %r12,%rdi
mov    0x30(%rsp),%r14
mov    %r14,%rsi
movsd  0x11c7(%rip),%xmm0
mov    %r15,0x40(%rsp)
mov    %r13,%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
push   %rax
push   0x30(%rsp)
push   0x90(%rsp)
push   %rbx
push   %rbp
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r15
mov    (%r15,%rsi,8),%r8
movsbl 0x0(%rbp,%r12,1),%r9d
movsbl 0x0(%rbp,%r14,1),%r11d
mov    0x88(%rsp),%r10
movsbl (%rdx,%r10,1),%ebx
sub    $0x8,%rsp
lea    0x478(%rsp),%r13
mov    %r13,%rdi
lea    0x11bc(%rip),%rsi
lea    0x168(%rsp),%rdx
xor    %eax,%eax
lea    0xd8(%rsp),%rbp
push   %rbp
lea    0x100(%rsp),%rbp
push   %rbp
push   $0x20
lea    0x60(%rsp),%rbp
push   %rbp
push   %rbx
push   (%r15,%r10,8)
push   %r11
call   1180 <sprintf@plt>
add    $0x40,%rsp
mov    0xa0(%rsp),%rax
mov    0x38(%rsp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
mov    %r13,%rsi
mov    %r12,%r13
call   1030 <strcpy@plt>
mov    0x60(%rsp),%r12
mov    %r12,0x38(%rsp)
jmp    1b58 <all_pairs+0x8b8>
nop
mov    %rbx,%r14
movsd  0x198(%rsp),%xmm0
mov    0x7b0(%rsp),%r8
ucomisd 0x10(%r8),%xmm0
jbe    1ffa <all_pairs+0xd5a>
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
jmp    2060 <all_pairs+0xdc0>
mov    %rsi,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
xor    %eax,%eax
jmp    1fca <all_pairs+0xd2a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
lea    (%rdx,%rcx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rcx
cmp    $0x1,%rdi
je     1d44 <all_pairs+0xaa4>
mov    (%rbx,%rcx,8),%rdi
cmpb   $0x20,0x3(%rdi)
je     1fde <all_pairs+0xd3e>
mov    (%r14,%rcx,8),%rdi
cmpb   $0x20,0x3(%rdi)
jne    1fe2 <all_pairs+0xd42>
add    $0x1,%rax
mov    0x8(%rbx,%rcx,8),%rdi
cmpb   $0x20,0x3(%rdi)
je     1fb0 <all_pairs+0xd10>
mov    0x8(%r14,%rcx,8),%rdi
cmpb   $0x20,0x3(%rdi)
je     1fb0 <all_pairs+0xd10>
jmp    1fb4 <all_pairs+0xd14>
mov    %rbp,%rbx
movsd  0x1a0(%rsp),%xmm0
movsd  0x18(%r8),%xmm1
addsd  0x103c(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    0x7c0(%rsp),%r12
mov    0x78(%rsp),%r15
mov    0x7b8(%rsp),%r13
mov    0x58(%rsp),%rbp
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
ja     2060 <all_pairs+0xdc0>
movsd  0x1a8(%rsp),%xmm0
ucomisd 0x20(%r8),%xmm0
jbe    24c1 <all_pairs+0x1221>
cs nopw 0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%r13
jmp    1b72 <all_pairs+0x8d2>
mov    0xc8(%rsp),%rax
cmp    $0xffffffffffffffff,%rax
mov    0x7c0(%rsp),%r9
mov    0x7b8(%rsp),%r13
mov    0x10(%rsp),%rdi
je     22c7 <all_pairs+0x1027>
cmp    $0x1,%rax
je     22c7 <all_pairs+0x1027>
cmp    $0x2,%rax
jne    239c <all_pairs+0x10fc>
mov    0x10(%rsp),%r15
movsbl (%r12,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x41,%al
jne    20e3 <all_pairs+0xe43>
mov    0x28(%rsp),%rax
movsbl (%r12,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     211a <all_pairs+0xe7a>
mov    0x28(%rsp),%rax
movsbl (%r12,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
je     211a <all_pairs+0xe7a>
mov    0x28(%rsp),%rax
movsbl (%r12,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x41,%al
jne    27dd <all_pairs+0x153d>
movsbl (%r12,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x55,%al
je     211a <all_pairs+0xe7a>
movsbl (%r12,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x54,%al
jne    27dd <all_pairs+0x153d>
lea    0x40(%rsp),%rdi
lea    0xfd2(%rip),%rsi
call   1030 <strcpy@plt>
jmp    239c <all_pairs+0x10fc>
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rsi
movsd  0xeea(%rip),%xmm0
mov    %r13,%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r14
push   %rbx
push   %r12
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
movsbl 0x40(%rsp),%edx
movsbl 0x42(%rsp),%ecx
movsbl 0x44(%rsp),%r8d
lea    0x1b(%rsp),%rbp
mov    %rbp,%rdi
lea    0xf5d(%rip),%rsi
xor    %eax,%eax
call   1180 <sprintf@plt>
mov    %rbp,%rdi
lea    0xf53(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    21ff <all_pairs+0xf5f>
lea    0x1b(%rsp),%rdi
lea    0xf3f(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    21ff <all_pairs+0xf5f>
movsd  0x1a0(%rsp),%xmm0
movsd  0x18(%r15),%xmm1
addsd  0xe60(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     21ff <all_pairs+0xf5f>
movsd  0x1a8(%rsp),%xmm0
movsd  0x20(%r15),%xmm1
addsd  0xe4b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    239c <all_pairs+0x10fc>
mov    0x38(%rsp),%r15
cmp    0x70(%rsp),%r15
jg     2cd2 <all_pairs+0x1a32>
lea    0x1(%r15),%rax
mov    %rax,0x60(%rsp)
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    %rdi,%rbp
mov    0x30(%rsp),%r14
mov    %r14,%rsi
movsd  0xe14(%rip),%xmm0
mov    %r15,0x40(%rsp)
mov    %r13,%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    0x7c8(%rsp),%r9
lea    0x48(%rsp),%r13
push   %r13
push   0x30(%rsp)
push   0x90(%rsp)
push   %rbx
push   %r12
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r10
mov    (%r10,%rsi,8),%r8
movsbl (%r12,%rbp,1),%r9d
mov    %rbp,%r15
movsbl (%r12,%r14,1),%r11d
mov    0x88(%rsp),%r13
movsbl (%rdx,%r13,1),%ebx
sub    $0x8,%rsp
lea    0x478(%rsp),%r12
mov    %r12,%rdi
lea    0xdf9(%rip),%rsi
jmp    1afd <all_pairs+0x85d>
sub    $0x8,%rsp
mov    0x30(%rsp),%rsi
movsd  0xd38(%rip),%xmm0
mov    %r13,%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r14
push   %rbx
push   %r12
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
movsbl 0x40(%rsp),%edx
movsbl 0x42(%rsp),%ecx
movsbl 0x44(%rsp),%r8d
lea    0x1b(%rsp),%rbp
mov    %rbp,%rdi
lea    0xdcb(%rip),%rsi
xor    %eax,%eax
call   1180 <sprintf@plt>
mov    %rbp,%rdi
lea    0xdc1(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    2353 <all_pairs+0x10b3>
lea    0x1b(%rsp),%rdi
lea    0xdad(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
je     239c <all_pairs+0x10fc>
sub    $0x8,%rsp
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rsi
movsd  0xcaf(%rip),%xmm0
mov    %r13,%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    0x7c8(%rsp),%r9
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r14
push   %rbx
push   %r12
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x10(%rsp),%r13
movsbl (%r12,%r13,1),%edi
mov    0x28(%rsp),%rbx
movsbl (%r12,%rbx,1),%esi
lea    0x40(%rsp),%r15
mov    %r15,%rdx
lea    0x250(%rsp),%rcx
call   1140 <LW_Saenger_correspond@plt>
mov    %r15,%rdi
call   1050 <ConvertState@plt>
mov    0xc0(%rsp),%rbp
mov    %al,-0x1(%rbp,%r13,1)
mov    %r15,%rdi
call   1050 <ConvertState@plt>
mov    %al,-0x1(%rbx,%rbp,1)
mov    0x30(%rsp),%r15
lea    0x1(%r15),%r12
movsbl 0x40(%rsp),%edx
movsbl 0x42(%rsp),%ecx
movsbl 0x44(%rsp),%r8d
lea    0x1b(%rsp),%rbp
mov    %rbp,%rdi
lea    0xcdf(%rip),%rsi
xor    %eax,%eax
call   1180 <sprintf@plt>
mov    0x800(%rsp),%rax
mov    0x8(%rax,%r15,8),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
cmp    0x188(%rsp),%r12
jge    2cd2 <all_pairs+0x1a32>
mov    0x808(%rsp),%rax
mov    0x8(%rax,%r15,8),%rax
mov    %r13,0x8(%rax)
mov    %rbx,0x10(%rax)
mov    0x98(%rsp),%rsi
mov    (%rsi,%r13,8),%rax
mov    0x328(%rax),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x328(%rax)
cmp    $0x63,%rcx
jg     19c7 <all_pairs+0x727>
mov    %rbx,0x8(%rax,%rcx,8)
mov    (%rsi,%rbx,8),%rax
mov    0x328(%rax),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x328(%rax)
cmp    $0x63,%rcx
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
jg     19d4 <all_pairs+0x734>
mov    %r13,0x8(%rax,%rcx,8)
mov    %r12,%rbp
mov    0x28(%rsp),%r14
mov    0x7b0(%rsp),%r8
jmp    1b72 <all_pairs+0x8d2>
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
mov    %r13,%rcx
mov    0x7c8(%rsp),%r8
mov    %r12,%r9
lea    0x158(%rsp),%rax
push   %rax
lea    0x198(%rsp),%rax
push   %rax
call   1090 <base_stack@plt>
add    $0x10,%rsp
cmpq   $0x0,0x158(%rsp)
jle    256d <all_pairs+0x12cd>
movsd  0xb68(%rip),%xmm0
ucomisd 0x1a8(%rsp),%xmm0
mov    0x30(%rsp),%rbp
mov    0x7b0(%rsp),%r8
jbe    27c6 <all_pairs+0x1526>
mov    %r8,%r13
lea    0xbe5(%rip),%r12
mov    %r12,%rdi
call   1050 <ConvertState@plt>
mov    0xc0(%rsp),%r15
mov    0x10(%rsp),%rbx
mov    %al,-0x1(%r15,%rbx,1)
mov    %r12,%rdi
call   1050 <ConvertState@plt>
mov    %r13,%r8
mov    %rbx,%r13
mov    %al,-0x1(%r14,%r15,1)
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
jmp    1b72 <all_pairs+0x8d2>
movsd  0x1a0(%rsp),%xmm0
mov    0x7b0(%rsp),%r8
ucomisd 0x18(%r8),%xmm0
ja     1f7c <all_pairs+0xcdc>
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    0x7b8(%rsp),%rdx
mov    0x7c8(%rsp),%rcx
mov    %rbx,%r8
mov    %r12,%r9
push   $0x1
push   $0x0
push   0x30(%rsp)
push   %r15
push   %rbp
lea    0x90(%rsp),%rax
push   %rax
call   1170 <Hbond_pair@plt>
add    $0x30,%rsp
cmpq   $0x0,0x68(%rsp)
jle    29e0 <all_pairs+0x1740>
xor    %ebx,%ebx
xor    %eax,%eax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%rcx
mov    0x7b0(%rsp),%r13
jmp    262d <all_pairs+0x138d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addq   $0x1,0x60(%rsp)
mov    0x8(%rsp),%rcx
mov    0x7c0(%rsp),%rbp
mov    0x7b0(%rsp),%r13
mov    0x68(%rsp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jge    284b <all_pairs+0x15ab>
mov    %rcx,%r12
mov    0x58(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xad9(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
je     2660 <all_pairs+0x13c0>
mov    %rbp,%rdi
lea    0xacb(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
jne    2690 <all_pairs+0x13f0>
mov    0x8(%r15,%rbx,8),%rax
movsbl 0x1(%rax),%esi
lea    0xab7(%rip),%rdi
call   10a0 <strchr@plt>
test   %rax,%rax
je     2690 <all_pairs+0x13f0>
mov    0x8(%r15,%rbx,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x50,%al
je     2690 <all_pairs+0x13f0>
cmp    $0x27,%al
jne    27b0 <all_pairs+0x1510>
nop
mov    0x8(%r15,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xa7e(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
je     26bb <all_pairs+0x141b>
mov    %rbp,%rdi
lea    0xa70(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
jne    2700 <all_pairs+0x1460>
mov    0x58(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rax
movsbl 0x1(%rax),%esi
lea    0xa57(%rip),%rdi
call   10a0 <strchr@plt>
test   %rax,%rax
je     2700 <all_pairs+0x1460>
mov    0x58(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rax
movzbl 0x3(%rax),%eax
cmp    $0x27,%al
je     2700 <all_pairs+0x1460>
cmp    $0x50,%al
jne    27b0 <all_pairs+0x1510>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%rax
mov    0x8(%rax,%rbx,8),%rbp
mov    %rbp,%rdi
lea    0xa16(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
je     2740 <all_pairs+0x14a0>
mov    %rbp,%rdi
lea    0xa08(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
je     2740 <all_pairs+0x14a0>
mov    0x8(%r15,%rbx,8),%r12
jmp    2760 <all_pairs+0x14c0>
nopw   0x0(%rax,%rax,1)
mov    0x8(%r15,%rbx,8),%r12
cmpb   $0x27,0x3(%r12)
je     2760 <all_pairs+0x14c0>
cmpb   $0x43,0x1(%r12)
jne    2600 <all_pairs+0x1360>
nopl   0x0(%rax)
mov    %r12,%rdi
lea    0x9c0(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
je     278a <all_pairs+0x14ea>
mov    %r12,%rdi
lea    0x9b2(%rip),%rsi
call   10d0 <strcmp@plt>
test   %eax,%eax
jne    2606 <all_pairs+0x1366>
cmpb   $0x27,0x3(%rbp)
je     2606 <all_pairs+0x1366>
cmpb   $0x43,0x1(%rbp)
jne    2600 <all_pairs+0x1360>
jmp    2606 <all_pairs+0x1366>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addq   $0x1,0x28(%rsp)
mov    0x7c0(%rsp),%rbp
mov    %r12,%rcx
jmp    261b <all_pairs+0x137b>
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r13
jmp    1b72 <all_pairs+0x8d2>
movsbl (%r12,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    27fe <all_pairs+0x155e>
mov    0x28(%rsp),%rax
movsbl (%r12,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
je     281f <all_pairs+0x157f>
mov    0x28(%rsp),%rax
movsbl (%r12,%rax,1),%edi
call   1040 <toupper@plt>
cmp    $0x47,%al
jne    2835 <all_pairs+0x1595>
movsbl (%r12,%r15,1),%edi
call   1040 <toupper@plt>
cmp    $0x43,%al
jne    2835 <all_pairs+0x1595>
lea    0x40(%rsp),%rdi
lea    0x8d6(%rip),%rsi
call   1030 <strcpy@plt>
jmp    239c <all_pairs+0x10fc>
lea    0x40(%rsp),%rdi
lea    0x8c9(%rip),%rsi
call   1030 <strcpy@plt>
jmp    239c <all_pairs+0x10fc>
cmp    0x28(%rsp),%rax
jne    29fc <all_pairs+0x175c>
mov    0xb8(%rsp),%rax
cmp    0x70(%rsp),%rax
mov    0x7f0(%rsp),%rbx
jg     2cd2 <all_pairs+0x1a32>
sub    $0x8,%rsp
mov    0x18(%rsp),%r13
mov    %r13,%rdi
mov    %r14,%rsi
movsd  0x7d8(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
lea    0x48(%rsp),%r12
push   %r12
push   0x30(%rsp)
push   %r15
mov    0x78(%rsp),%r12
push   %r12
push   %rbx
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
lea    0x1b(%rsp),%rdi
lea    0x827(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    28ed <all_pairs+0x164d>
lea    0x1b(%rsp),%rdi
lea    0x813(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
je     2932 <all_pairs+0x1692>
sub    $0x8,%rsp
mov    %r13,%rdi
mov    %r14,%rsi
movsd  0x769(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r15
push   %r12
push   %rbx
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x120(%rsp),%rax
mov    0xb8(%rsp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
add    $0x1,%rcx
mov    %rcx,0xb8(%rsp)
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r10
mov    (%r10,%rsi,8),%r8
movsbl (%rbx,%r13,1),%r9d
movsbl (%rbx,%r14,1),%r11d
mov    0x88(%rsp),%r15
movsbl (%rdx,%r15,1),%ebx
sub    $0x8,%rsp
lea    0x79f(%rip),%rsi
lea    0x168(%rsp),%rdx
xor    %eax,%eax
lea    0xd8(%rsp),%rbp
push   %rbp
lea    0x100(%rsp),%rbp
push   %rbp
push   $0x20
lea    0x60(%rsp),%rbp
push   %rbp
push   %rbx
push   (%r10,%r15,8)
push   %r11
call   1180 <sprintf@plt>
add    $0x40,%rsp
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rbp
jmp    24b4 <all_pairs+0x1214>
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rbp
mov    0x10(%rsp),%r13
jmp    24b4 <all_pairs+0x1214>
cmp    0x60(%rsp),%rax
mov    0x7f0(%rsp),%r13
jne    2b4c <all_pairs+0x18ac>
mov    0xb0(%rsp),%rax
cmp    0x70(%rsp),%rax
lea    0x40(%rsp),%rax
jg     2cd2 <all_pairs+0x1a32>
sub    $0x8,%rsp
mov    0x18(%rsp),%r12
mov    %r12,%rdi
mov    %r14,%rsi
movsd  0x622(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
push   %rax
push   0x30(%rsp)
push   %r15
mov    0x78(%rsp),%rbx
push   %rbx
push   %r13
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
lea    0x1b(%rsp),%rdi
lea    0x677(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    2a9d <all_pairs+0x17fd>
lea    0x1b(%rsp),%rdi
lea    0x663(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
je     2ae2 <all_pairs+0x1842>
sub    $0x8,%rsp
mov    %r12,%rdi
mov    %r14,%rsi
movsd  0x5b9(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r15
push   %rbx
push   %r13
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x118(%rsp),%rax
mov    0xb0(%rsp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
add    $0x1,%rcx
mov    %rcx,0xb0(%rsp)
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r10
mov    (%r10,%rsi,8),%r8
movsbl 0x0(%r13,%r12,1),%r9d
movsbl 0x0(%r13,%r14,1),%r11d
mov    0x88(%rsp),%r15
movsbl (%rdx,%r15,1),%ebx
sub    $0x8,%rsp
lea    0x61c(%rip),%rsi
jmp    2c84 <all_pairs+0x19e4>
mov    0xa8(%rsp),%rax
cmp    0x70(%rsp),%rax
lea    0x40(%rsp),%rax
jg     2cd2 <all_pairs+0x1a32>
sub    $0x8,%rsp
mov    0x18(%rsp),%r12
mov    %r12,%rdi
mov    %r14,%rsi
movsd  0x48d(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
push   %rax
push   0x30(%rsp)
push   %r15
mov    0x78(%rsp),%rbx
push   %rbx
push   %r13
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
lea    0x1b(%rsp),%rdi
lea    0x53a(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
jne    2bda <all_pairs+0x193a>
lea    0x1b(%rsp),%rdi
lea    0x526(%rip),%rsi
call   11b0 <strstr@plt>
test   %rax,%rax
je     2c1f <all_pairs+0x197f>
sub    $0x8,%rsp
mov    %r12,%rdi
mov    %r14,%rsi
movsd  0x46c(%rip),%xmm0
mov    0x7c0(%rsp),%rdx
mov    0x7d0(%rsp),%rcx
lea    0x278(%rsp),%r8
mov    %rbp,%r9
lea    0x48(%rsp),%rax
push   %rax
push   0x30(%rsp)
push   %r15
push   %rbx
push   %r13
call   1160 <LW_pair_type@plt>
add    $0x30,%rsp
mov    0x110(%rsp),%rax
mov    0xa8(%rsp),%rcx
mov    0x8(%rax,%rcx,8),%rdi
add    $0x1,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x7d8(%rsp),%rdx
mov    0x80(%rsp),%rsi
movsbl (%rdx,%rsi,1),%ecx
mov    0x7e0(%rsp),%r10
mov    (%r10,%rsi,8),%r8
movsbl 0x0(%r13,%r12,1),%r9d
movsbl 0x0(%r13,%r14,1),%r11d
mov    0x88(%rsp),%r15
movsbl (%rdx,%r15,1),%ebx
sub    $0x8,%rsp
lea    0x514(%rip),%rsi
lea    0x168(%rsp),%rdx
xor    %eax,%eax
lea    0xd8(%rsp),%rbp
push   %rbp
lea    0x100(%rsp),%rbp
push   %rbp
push   $0x20
lea    0x60(%rsp),%rbp
push   %rbp
push   %rbx
push   (%r10,%r15,8)
push   %r11
call   1180 <sprintf@plt>
add    $0x40,%rsp
mov    0x838(%rsp),%rdx
mov    0x8(%rsp),%rdi
mov    0x30(%rsp),%rbp
mov    %r12,%r13
jmp    24b4 <all_pairs+0x1214>
xor    %eax,%eax
add    $0x778,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [1 x i8] zeroinitializer
@.str.1 = [5 x i8] c"%3s \00"
@.str.2 = [4 x i8] c"syn\00"
@.str.3 = [3 x i8] c" \00"
@.str.4 = [6 x i8] c"%d_%d\00"
@.str.5 = [49 x i8] c"%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !1H(b_b)\0A\00"
@.str.6 = [50 x i8] c"%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !1H(b_b).\0A\00"
@.str.7 = [7 x i8] c"%c%c%c\00"
@.str.8 = [2 x i8] c".\00"
@.str.9 = [2 x i8] c"?\00"
@.str.10 = [9 x i8] c"-/- cis \00"
@.str.11 = [9 x i8] c"+/+ cis \00"
@.str.12 = [9 x i8] c"X/X cis \00"
@.str.13 = [10 x i8] c" stacked \00"
@.str.14 = [5 x i8] c" O2'\00"
@.str.15 = [5 x i8] c" O4'\00"
@.str.16 = [3 x i8] c"NO\00"
@.str.17 = [5 x i8] c" O1P\00"
@.str.18 = [5 x i8] c" O2P\00"
@.str.19 = [47 x i8] c"%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !(b_s)\0A\00"
@.str.20 = [53 x i8] c"%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !b_(O1P,O2P)\0A\00"
@.str.21 = [47 x i8] c"%9s, %c: %5d %c-%c %5d %c: %7s %c %s%s !(s_s)\0A\00"
define i8* @all_pairs(i8* %0, i64 %1, i64* %2, double** %3, double** %4, double** %5, double* %6, i64** %7, double** %8, i8** %9, i8** %10, i8* %11, i64* %12, i8** %13, i8* %14, i64* %15, i8** %16, i64** %17, i64* %18, i64* %19, i64* %20, i64* %21, i64** %22, i64* %23) {
%25 = alloca i8*
%26 = alloca i8*
%27 = alloca i64
%28 = alloca i64*
%29 = alloca double**
%30 = alloca double**
%31 = alloca double**
%32 = alloca double*
%33 = alloca i64**
%34 = alloca double**
%35 = alloca i8**
%36 = alloca i8**
%37 = alloca i8*
%38 = alloca i64*
%39 = alloca i8**
%40 = alloca i8*
%41 = alloca i64*
%42 = alloca i8**
%43 = alloca i64**
%44 = alloca i64*
%45 = alloca i64*
%46 = alloca i64*
%47 = alloca i64*
%48 = alloca i64**
%49 = alloca i64*
%50 = alloca [512 x i8]
%51 = alloca i8
%52 = alloca [20 x i8]
%53 = alloca [512 x i8]
%54 = alloca [512 x i8]
%55 = alloca i8**
%56 = alloca [20 x i8]
%57 = alloca [5 x i8]
%58 = alloca i8**
%59 = alloca i8**
%60 = alloca [20 x i8]
%61 = alloca [20 x i8]
%62 = alloca [20 x i8]
%63 = alloca [256 x i8]
%64 = alloca i8**
%65 = alloca i8**
%66 = alloca i8**
%67 = alloca i8**
%68 = alloca i64
%69 = alloca i64
%70 = alloca i64
%71 = alloca i64
%72 = alloca i64
%73 = alloca i64
%74 = alloca i64
%75 = alloca i64
%76 = alloca i64
%77 = alloca i64
%78 = alloca i64
%79 = alloca i64
%80 = alloca i64
%81 = alloca i64
%82 = alloca i64
%83 = alloca i64
%84 = alloca i64
%85 = alloca i64**
%86 = alloca i64*
%87 = alloca i64
%88 = alloca i64
%89 = alloca i64
%90 = alloca [21 x double]
%91 = alloca [2 x double]
%92 = alloca double*
%93 = alloca double
%94 = alloca double
%95 = alloca i8*
store i8* %0, i8** %26
store i64 %1, i64* %27
store i64* %2, i64** %28
store double** %3, double*** %29
store double** %4, double*** %30
store double** %5, double*** %31
store double* %6, double** %32
store i64** %7, i64*** %33
store double** %8, double*** %34
store i8** %9, i8*** %35
store i8** %10, i8*** %36
store i8* %11, i8** %37
store i64* %12, i64** %38
store i8** %13, i8*** %39
store i8* %14, i8** %40
store i64* %15, i64** %41
store i8** %16, i8*** %42
store i64** %17, i64*** %43
store i64* %18, i64** %44
store i64* %19, i64** %45
store i64* %20, i64** %46
store i64* %21, i64** %47
store i64** %22, i64*** %48
store i64* %23, i64** %49
store i8 32, i8* %51
store i64 0, i64* %68
store i64 0, i64* %69
store i64 0, i64* %70
store i64 0, i64* %71
store i64 0, i64* %74
store i64 0, i64* %80
store i64 0, i64* %82
store i64 0, i64* %87
store i64 0, i64* %88
store i64 0, i64* %89
%96 = load i64, i64* %27
%97 = add nsw i64 %96, 1
%98 = mul i64 1, %97
%99 = trunc i64 %98 to i32
%100 = call i8* @malloc(i32 %99)
store i8* %100, i8** %95
store i64 0, i64* %75
br label %101
101: ; preds = %109, %24
%102 = load i64, i64* %75
%103 = load i64, i64* %27
%104 = icmp slt i64 %102, %103
br i1 %104, label %105, label %112
105: ; preds = %101
%106 = load i8*, i8** %95
%107 = load i64, i64* %75
%108 = getelementptr inbounds i8, i8* %106, i64 %107
store i8 46, i8* %108
br label %109
109: ; preds = %105
%110 = load i64, i64* %75
%111 = add nsw i64 %110, 1
store i64 %111, i64* %75
br label %101
112: ; preds = %101
%113 = load i8*, i8** %95
%114 = load i64, i64* %27
%115 = getelementptr inbounds i8, i8* %113, i64 %114
store i8 0, i8* %115
%116 = load i64, i64* %27
%117 = call i8** @cmatrix(i32 0, i64 %116, i32 0, i32 120)
store i8** %117, i8*** %64
%118 = load i64, i64* %27
%119 = call i8** @cmatrix(i32 0, i64 %118, i32 0, i32 120)
store i8** %119, i8*** %65
%120 = load i64, i64* %27
%121 = call i8** @cmatrix(i32 0, i64 %120, i32 0, i32 120)
store i8** %121, i8*** %66
%122 = load i64, i64* %27
%123 = call i8** @cmatrix(i32 0, i64 %122, i32 0, i32 120)
store i8** %123, i8*** %67
%124 = call i8** @cmatrix(i32 0, i64 512, i32 0, i32 4)
store i8** %124, i8*** %58
%125 = call i8** @cmatrix(i32 0, i64 512, i32 0, i32 4)
store i8** %125, i8*** %59
%126 = call double* @dvector(i32 0, i32 512)
store double* %126, double** %92
%127 = getelementptr inbounds [2 x double], [2 x double]* %91, i64 0, i64 0
%128 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%129 = getelementptr inbounds [512 x i8], [512 x i8]* %53, i64 0, i64 0
%130 = call i32 @hb_crt_alt(double* %127, i8* %128, i8* %129)
%131 = load i64, i64* %27
%132 = call i64** @lmatrix(i32 0, i64 %131, i32 0, i64 101)
store i64** %132, i64*** %85
%133 = load i64, i64* %27
%134 = call i64* @lvector(i32 0, i64 %133)
store i64* %134, i64** %86
store i64 0, i64* %75
br label %135
135: ; preds = %154, %112
%136 = load i64, i64* %75
%137 = load i64, i64* %27
%138 = icmp sle i64 %136, %137
br i1 %138, label %139, label %157
139: ; preds = %135
store i64 0, i64* %77
br label %140
140: ; preds = %150, %139
%141 = load i64, i64* %77
%142 = icmp sle i64 %141, 101
br i1 %142, label %143, label %153
143: ; preds = %140
%144 = load i64**, i64*** %85
%145 = load i64, i64* %75
%146 = getelementptr inbounds i64*, i64** %144, i64 %145
%147 = load i64*, i64** %146
%148 = load i64, i64* %77
%149 = getelementptr inbounds i64, i64* %147, i64 %148
store i64 0, i64* %149
br label %150
150: ; preds = %143
%151 = load i64, i64* %77
%152 = add nsw i64 %151, 1
store i64 %152, i64* %77
br label %140
153: ; preds = %140
br label %154
154: ; preds = %153
%155 = load i64, i64* %75
%156 = add nsw i64 %155, 1
store i64 %156, i64* %75
br label %135
157: ; preds = %135
store i64 0, i64* %75
br label %158
158: ; preds = %175, %157
%159 = load i64, i64* %75
%160 = icmp slt i64 %159, 512
br i1 %160, label %161, label %178
161: ; preds = %158
%162 = load i8**, i8*** %58
%163 = load i64, i64* %75
%164 = getelementptr inbounds i8*, i8** %162, i64 %163
%165 = load i8*, i8** %164
%166 = call i32 @strcpy(i8* %165, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%167 = load i8**, i8*** %59
%168 = load i64, i64* %75
%169 = getelementptr inbounds i8*, i8** %167, i64 %168
%170 = load i8*, i8** %169
%171 = call i32 @strcpy(i8* %170, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%172 = load double*, double** %92
%173 = load i64, i64* %75
%174 = getelementptr inbounds double, double* %172, i64 %173
store double 0.000000e+00, double* %174
br label %175
175: ; preds = %161
%176 = load i64, i64* %75
%177 = add nsw i64 %176, 1
store i64 %177, i64* %75
br label %158
178: ; preds = %158
store i64 1, i64* %75
br label %179
179: ; preds = %190, %178
%180 = load i64, i64* %75
%181 = load i64, i64* %27
%182 = icmp sle i64 %180, %181
br i1 %182, label %183, label %193
183: ; preds = %179
%184 = load i64*, i64** %86
%185 = load i64, i64* %75
%186 = getelementptr inbounds i64, i64* %184, i64 %185
store i64 0, i64* %186
%187 = load i64*, i64** %49
%188 = load i64, i64* %75
%189 = getelementptr inbounds i64, i64* %187, i64 %188
store i64 0, i64* %189
br label %190
190: ; preds = %183
%191 = load i64, i64* %75
%192 = add nsw i64 %191, 1
store i64 %192, i64* %75
br label %179
193: ; preds = %179
%194 = load i64, i64* %27
%195 = load i8**, i8*** %35
%196 = load i64**, i64*** %33
%197 = load double**, double*** %34
%198 = load i64*, i64** %28
%199 = load i64*, i64** %49
%200 = call i32 @syn_or_anti(i64 %194, i8** %195, i64** %196, double** %197, i64* %198, i64* %199)
store i64 1, i64* %75
br label %201
201: ; preds = %1396, %193
%202 = load i64, i64* %75
%203 = load i64, i64* %27
%204 = icmp slt i64 %202, %203
br i1 %204, label %205, label %1399
205: ; preds = %201
%206 = load i64, i64* %75
%207 = add nsw i64 %206, 1
store i64 %207, i64* %77
br label %208
208: ; preds = %1392, %205
%209 = load i64, i64* %77
%210 = load i64, i64* %27
%211 = icmp sle i64 %209, %210
br i1 %211, label %212, label %1395
212: ; preds = %208
%213 = load i64**, i64*** %33
%214 = load i64, i64* %75
%215 = getelementptr inbounds i64*, i64** %213, i64 %214
%216 = load i64*, i64** %215
%217 = getelementptr inbounds i64, i64* %216, i64 1
%218 = load i64, i64* %217
store i64 %218, i64* %76
%219 = load i64**, i64*** %33
%220 = load i64, i64* %77
%221 = getelementptr inbounds i64*, i64** %219, i64 %220
%222 = load i64*, i64** %221
%223 = getelementptr inbounds i64, i64* %222, i64 1
%224 = load i64, i64* %223
store i64 %224, i64* %78
%225 = load i64*, i64** %49
%226 = load i64, i64* %75
%227 = getelementptr inbounds i64, i64* %225, i64 %226
%228 = load i64, i64* %227
%229 = icmp eq i64 %228, 1
br i1 %229, label %230, label %233
230: ; preds = %212
%231 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%232 = call i32 (i8*, i8*, ...) @sprintf(i8* %231, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
br label %236
233: ; preds = %212
%234 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%235 = call i32 @strcpy(i8* %234, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
br label %236
236: ; preds = %233, %230
%237 = load i64*, i64** %49
%238 = load i64, i64* %77
%239 = getelementptr inbounds i64, i64* %237, i64 %238
%240 = load i64, i64* %239
%241 = icmp eq i64 %240, 1
br i1 %241, label %242, label %245
242: ; preds = %236
%243 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%244 = call i32 (i8*, i8*, ...) @sprintf(i8* %243, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
br label %248
245: ; preds = %236
%246 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%247 = call i32 @strcpy(i8* %246, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
br label %248
248: ; preds = %245, %242
%249 = load i64, i64* %75
%250 = load i64, i64* %77
%251 = load i8*, i8** %40
%252 = load i64**, i64*** %33
%253 = load double**, double*** %34
%254 = load double**, double*** %29
%255 = load double**, double*** %30
%256 = load double**, double*** %31
%257 = load i8**, i8*** %35
%258 = load double*, double** %32
%259 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 0
%260 = call i32 @check_pairs(i64 %249, i64 %250, i8* %251, i64** %252, double** %253, double** %254, double** %255, double** %256, i8** %257, double* %258, double* %259, i64* %74, i32 0)
%261 = load i64, i64* %74
%262 = icmp ne i64 %261, 0
br i1 %262, label %263, label %876
263: ; preds = %248
%264 = load i64**, i64*** %33
%265 = load i64, i64* %75
%266 = getelementptr inbounds i64*, i64** %264, i64 %265
%267 = load i64*, i64** %266
%268 = getelementptr inbounds i64, i64* %267, i64 1
%269 = load i64, i64* %268
store i64 %269, i64* %76
%270 = load i64**, i64*** %33
%271 = load i64, i64* %77
%272 = getelementptr inbounds i64*, i64** %270, i64 %271
%273 = load i64*, i64** %272
%274 = getelementptr inbounds i64, i64* %273, i64 1
%275 = load i64, i64* %274
store i64 %275, i64* %78
%276 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%277 = load i64, i64* %75
%278 = load i64, i64* %77
%279 = call i32 (i8*, i8*, ...) @sprintf(i8* %276, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i64 %277, i64 %278)
store double 3.500000e-01, double* %93
store i64 1, i64* %83
store i64 0, i64* %84
%280 = load i64, i64* %75
%281 = load i64, i64* %77
%282 = load i64**, i64*** %33
%283 = load i8**, i8*** %35
%284 = load i8*, i8** %40
%285 = load double**, double*** %34
%286 = load double, double* %93
%287 = load i8**, i8*** %58
%288 = load i8**, i8*** %59
%289 = load double*, double** %92
%290 = load i64, i64* %83
%291 = load i64, i64* %84
%292 = call i32 @Hbond_pair(i64 %280, i64 %281, i64** %282, i8** %283, i8* %284, double** %285, double %286, i64* %81, i8** %287, i8** %288, double* %289, i64 %290, i64 %291)
store i64 0, i64* %89
store i64 1, i64* %79
br label %293
293: ; preds = %319, %263
%294 = load i64, i64* %79
%295 = load i64, i64* %81
%296 = icmp sle i64 %294, %295
br i1 %296, label %297, label %322
297: ; preds = %293
%298 = load i8**, i8*** %58
%299 = load i64, i64* %79
%300 = getelementptr inbounds i8*, i8** %298, i64 %299
%301 = load i8*, i8** %300
%302 = getelementptr inbounds i8, i8* %301, i64 3
%303 = load i8, i8* %302
%304 = sext i8 %303 to i32
%305 = icmp ne i32 %304, 32
br i1 %305, label %306, label %316
306: ; preds = %297
%307 = load i8**, i8*** %59
%308 = load i64, i64* %79
%309 = getelementptr inbounds i8*, i8** %307, i64 %308
%310 = load i8*, i8** %309
%311 = getelementptr inbounds i8, i8* %310, i64 3
%312 = load i8, i8* %311
%313 = sext i8 %312 to i32
%314 = icmp ne i32 %313, 32
br i1 %314, label %315, label %316
315: ; preds = %306
br label %319
316: ; preds = %306, %297
%317 = load i64, i64* %89
%318 = add nsw i64 %317, 1
store i64 %318, i64* %89
br label %319
319: ; preds = %316, %315
%320 = load i64, i64* %79
%321 = add nsw i64 %320, 1
store i64 %321, i64* %79
br label %293
322: ; preds = %293
%323 = load i64, i64* %89
%324 = icmp eq i64 %323, 1
br i1 %324, label %325, label %388
325: ; preds = %322
%326 = load i64, i64* %68
%327 = add nsw i64 %326, 1
store i64 %327, i64* %68
%328 = load i64, i64* %27
%329 = sub nsw i64 %328, 2
%330 = icmp sgt i64 %326, %329
br i1 %330, label %331, label %332
331: ; preds = %325
store i8* null, i8** %25
br label %1450
332: ; preds = %325
store double 5.200000e+00, double* %94
%333 = load i64, i64* %75
%334 = load i64, i64* %77
%335 = load double, double* %94
%336 = load i64**, i64*** %33
%337 = load i8**, i8*** %35
%338 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%339 = load double**, double*** %34
%340 = load i8*, i8** %40
%341 = load i8**, i8*** %58
%342 = load i8**, i8*** %59
%343 = load double*, double** %92
%344 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%345 = call i32 @LW_pair_type(i64 %333, i64 %334, double %335, i64** %336, i8** %337, i8* %338, double** %339, i8* %340, i8** %341, i8** %342, double* %343, i8* %344)
%346 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%347 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%348 = load i8*, i8** %37
%349 = load i64, i64* %76
%350 = getelementptr inbounds i8, i8* %348, i64 %349
%351 = load i8, i8* %350
%352 = sext i8 %351 to i32
%353 = load i64*, i64** %38
%354 = load i64, i64* %76
%355 = getelementptr inbounds i64, i64* %353, i64 %354
%356 = load i64, i64* %355
%357 = load i8*, i8** %40
%358 = load i64, i64* %75
%359 = getelementptr inbounds i8, i8* %357, i64 %358
%360 = load i8, i8* %359
%361 = sext i8 %360 to i32
%362 = load i8*, i8** %40
%363 = load i64, i64* %77
%364 = getelementptr inbounds i8, i8* %362, i64 %363
%365 = load i8, i8* %364
%366 = sext i8 %365 to i32
%367 = load i64*, i64** %38
%368 = load i64, i64* %78
%369 = getelementptr inbounds i64, i64* %367, i64 %368
%370 = load i64, i64* %369
%371 = load i8*, i8** %37
%372 = load i64, i64* %78
%373 = getelementptr inbounds i8, i8* %371, i64 %372
%374 = load i8, i8* %373
%375 = sext i8 %374 to i32
%376 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%377 = load i8, i8* %51
%378 = sext i8 %377 to i32
%379 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%380 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%381 = call i32 (i8*, i8*, ...) @sprintf(i8* %346, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i8* %347, i32 %352, i64 %356, i32 %361, i32 %366, i64 %370, i32 %375, i8* %376, i32 %378, i8* %379, i8* %380)
%382 = load i8**, i8*** %64
%383 = load i64, i64* %68
%384 = getelementptr inbounds i8*, i8** %382, i64 %383
%385 = load i8*, i8** %384
%386 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%387 = call i32 @strcpy(i8* %385, i8* %386)
br label %1392
388: ; preds = %322
%389 = load i64, i64* %81
%390 = call i8** @cmatrix(i32 0, i64 %389, i32 0, i32 4)
store i8** %390, i8*** %55
%391 = load i64, i64* %81
%392 = load i8**, i8*** %58
%393 = load i8**, i8*** %55
%394 = call i32 @get_unequility(i64 %391, i8** %392, i64* %87, i8** %393)
%395 = load i64, i64* %81
%396 = load i8**, i8*** %59
%397 = load i8**, i8*** %55
%398 = call i32 @get_unequility(i64 %395, i8** %396, i64* %88, i8** %397)
%399 = load i8**, i8*** %55
%400 = load i64, i64* %81
%401 = trunc i64 %400 to i32
%402 = call i32 @free_cmatrix(i8** %399, i32 0, i32 %401, i32 0, i32 4)
%403 = load i64, i64* %87
%404 = icmp eq i64 %403, 1
br i1 %404, label %405, label %408
405: ; preds = %388
%406 = load i64, i64* %88
%407 = icmp sgt i64 %406, 1
br i1 %407, label %414, label %408
408: ; preds = %405, %388
%409 = load i64, i64* %88
%410 = icmp eq i64 %409, 1
br i1 %410, label %411, label %605
411: ; preds = %408
%412 = load i64, i64* %87
%413 = icmp sgt i64 %412, 1
br i1 %413, label %414, label %605
414: ; preds = %411, %405
%415 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 2
%416 = load double, double* %415
%417 = load double*, double** %32
%418 = getelementptr inbounds double, double* %417, i64 3
%419 = load double, double* %418
%420 = fsub double %419, 6.000000e-01
%421 = fcmp ogt double %416, %420
br i1 %421, label %430, label %422
422: ; preds = %414
%423 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 3
%424 = load double, double* %423
%425 = load double*, double** %32
%426 = getelementptr inbounds double, double* %425, i64 4
%427 = load double, double* %426
%428 = fsub double %427, 2.000000e+01
%429 = fcmp ogt double %424, %428
br i1 %429, label %430, label %493
430: ; preds = %422, %414
%431 = load i64, i64* %68
%432 = add nsw i64 %431, 1
store i64 %432, i64* %68
%433 = load i64, i64* %27
%434 = sub nsw i64 %433, 2
%435 = icmp sgt i64 %431, %434
br i1 %435, label %436, label %437
436: ; preds = %430
store i8* null, i8** %25
br label %1450
437: ; preds = %430
store double 5.000000e+00, double* %94
%438 = load i64, i64* %75
%439 = load i64, i64* %77
%440 = load double, double* %94
%441 = load i64**, i64*** %33
%442 = load i8**, i8*** %35
%443 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%444 = load double**, double*** %34
%445 = load i8*, i8** %40
%446 = load i8**, i8*** %58
%447 = load i8**, i8*** %59
%448 = load double*, double** %92
%449 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%450 = call i32 @LW_pair_type(i64 %438, i64 %439, double %440, i64** %441, i8** %442, i8* %443, double** %444, i8* %445, i8** %446, i8** %447, double* %448, i8* %449)
%451 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%452 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%453 = load i8*, i8** %37
%454 = load i64, i64* %76
%455 = getelementptr inbounds i8, i8* %453, i64 %454
%456 = load i8, i8* %455
%457 = sext i8 %456 to i32
%458 = load i64*, i64** %38
%459 = load i64, i64* %76
%460 = getelementptr inbounds i64, i64* %458, i64 %459
%461 = load i64, i64* %460
%462 = load i8*, i8** %40
%463 = load i64, i64* %75
%464 = getelementptr inbounds i8, i8* %462, i64 %463
%465 = load i8, i8* %464
%466 = sext i8 %465 to i32
%467 = load i8*, i8** %40
%468 = load i64, i64* %77
%469 = getelementptr inbounds i8, i8* %467, i64 %468
%470 = load i8, i8* %469
%471 = sext i8 %470 to i32
%472 = load i64*, i64** %38
%473 = load i64, i64* %78
%474 = getelementptr inbounds i64, i64* %472, i64 %473
%475 = load i64, i64* %474
%476 = load i8*, i8** %37
%477 = load i64, i64* %78
%478 = getelementptr inbounds i8, i8* %476, i64 %477
%479 = load i8, i8* %478
%480 = sext i8 %479 to i32
%481 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%482 = load i8, i8* %51
%483 = sext i8 %482 to i32
%484 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%485 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%486 = call i32 (i8*, i8*, ...) @sprintf(i8* %451, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.6, i64 0, i64 0), i8* %452, i32 %457, i64 %461, i32 %466, i32 %471, i64 %475, i32 %480, i8* %481, i32 %483, i8* %484, i8* %485)
%487 = load i8**, i8*** %64
%488 = load i64, i64* %68
%489 = getelementptr inbounds i8*, i8** %487, i64 %488
%490 = load i8*, i8** %489
%491 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%492 = call i32 @strcpy(i8* %490, i8* %491)
br label %1392
493: ; preds = %422
store double 4.329000e+00, double* %94
%494 = load i64, i64* %75
%495 = load i64, i64* %77
%496 = load double, double* %94
%497 = load i64**, i64*** %33
%498 = load i8**, i8*** %35
%499 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%500 = load double**, double*** %34
%501 = load i8*, i8** %40
%502 = load i8**, i8*** %58
%503 = load i8**, i8*** %59
%504 = load double*, double** %92
%505 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%506 = call i32 @LW_pair_type(i64 %494, i64 %495, double %496, i64** %497, i8** %498, i8* %499, double** %500, i8* %501, i8** %502, i8** %503, double* %504, i8* %505)
%507 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%508 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%509 = load i8, i8* %508
%510 = sext i8 %509 to i32
%511 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 2
%512 = load i8, i8* %511
%513 = sext i8 %512 to i32
%514 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 4
%515 = load i8, i8* %514
%516 = sext i8 %515 to i32
%517 = call i32 (i8*, i8*, ...) @sprintf(i8* %507, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %510, i32 %513, i32 %516)
%518 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%519 = call i64 @strstr(i8* %518, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%520 = icmp ne i64 %519, 0
br i1 %520, label %541, label %521
521: ; preds = %493
%522 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%523 = call i64 @strstr(i8* %522, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%524 = icmp ne i64 %523, 0
br i1 %524, label %541, label %525
525: ; preds = %521
%526 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 2
%527 = load double, double* %526
%528 = load double*, double** %32
%529 = getelementptr inbounds double, double* %528, i64 3
%530 = load double, double* %529
%531 = fsub double %530, 4.000000e-01
%532 = fcmp ogt double %527, %531
br i1 %532, label %541, label %533
533: ; preds = %525
%534 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 3
%535 = load double, double* %534
%536 = load double*, double** %32
%537 = getelementptr inbounds double, double* %536, i64 4
%538 = load double, double* %537
%539 = fsub double %538, 1.500000e+01
%540 = fcmp ogt double %535, %539
br i1 %540, label %541, label %604
541: ; preds = %533, %525, %521, %493
%542 = load i64, i64* %68
%543 = add nsw i64 %542, 1
store i64 %543, i64* %68
%544 = load i64, i64* %27
%545 = sub nsw i64 %544, 2
%546 = icmp sgt i64 %542, %545
br i1 %546, label %547, label %548
547: ; preds = %541
store i8* null, i8** %25
br label %1450
548: ; preds = %541
store double 5.000000e+00, double* %94
%549 = load i64, i64* %75
%550 = load i64, i64* %77
%551 = load double, double* %94
%552 = load i64**, i64*** %33
%553 = load i8**, i8*** %35
%554 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%555 = load double**, double*** %34
%556 = load i8*, i8** %40
%557 = load i8**, i8*** %58
%558 = load i8**, i8*** %59
%559 = load double*, double** %92
%560 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%561 = call i32 @LW_pair_type(i64 %549, i64 %550, double %551, i64** %552, i8** %553, i8* %554, double** %555, i8* %556, i8** %557, i8** %558, double* %559, i8* %560)
%562 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%563 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%564 = load i8*, i8** %37
%565 = load i64, i64* %76
%566 = getelementptr inbounds i8, i8* %564, i64 %565
%567 = load i8, i8* %566
%568 = sext i8 %567 to i32
%569 = load i64*, i64** %38
%570 = load i64, i64* %76
%571 = getelementptr inbounds i64, i64* %569, i64 %570
%572 = load i64, i64* %571
%573 = load i8*, i8** %40
%574 = load i64, i64* %75
%575 = getelementptr inbounds i8, i8* %573, i64 %574
%576 = load i8, i8* %575
%577 = sext i8 %576 to i32
%578 = load i8*, i8** %40
%579 = load i64, i64* %77
%580 = getelementptr inbounds i8, i8* %578, i64 %579
%581 = load i8, i8* %580
%582 = sext i8 %581 to i32
%583 = load i64*, i64** %38
%584 = load i64, i64* %78
%585 = getelementptr inbounds i64, i64* %583, i64 %584
%586 = load i64, i64* %585
%587 = load i8*, i8** %37
%588 = load i64, i64* %78
%589 = getelementptr inbounds i8, i8* %587, i64 %588
%590 = load i8, i8* %589
%591 = sext i8 %590 to i32
%592 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%593 = load i8, i8* %51
%594 = sext i8 %593 to i32
%595 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%596 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%597 = call i32 (i8*, i8*, ...) @sprintf(i8* %562, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.6, i64 0, i64 0), i8* %563, i32 %568, i64 %572, i32 %577, i32 %582, i64 %586, i32 %591, i8* %592, i32 %594, i8* %595, i8* %596)
%598 = load i8**, i8*** %64
%599 = load i64, i64* %68
%600 = getelementptr inbounds i8*, i8** %598, i64 %599
%601 = load i8*, i8** %600
%602 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%603 = call i32 @strcpy(i8* %601, i8* %602)
br label %1392
604: ; preds = %533
br label %754
605: ; preds = %411, %408
%606 = load i64, i64* %74
%607 = icmp eq i64 %606, 2
br i1 %607, label %608, label %699
608: ; preds = %605
%609 = load i8*, i8** %40
%610 = load i64, i64* %75
%611 = getelementptr inbounds i8, i8* %609, i64 %610
%612 = load i8, i8* %611
%613 = call signext i8 @toupper(i8 signext %612)
%614 = sext i8 %613 to i32
%615 = icmp eq i32 %614, 65
br i1 %615, label %616, label %632
616: ; preds = %608
%617 = load i8*, i8** %40
%618 = load i64, i64* %77
%619 = getelementptr inbounds i8, i8* %617, i64 %618
%620 = load i8, i8* %619
%621 = call signext i8 @toupper(i8 signext %620)
%622 = sext i8 %621 to i32
%623 = icmp eq i32 %622, 85
br i1 %623, label %656, label %624
624: ; preds = %616
%625 = load i8*, i8** %40
%626 = load i64, i64* %77
%627 = getelementptr inbounds i8, i8* %625, i64 %626
%628 = load i8, i8* %627
%629 = call signext i8 @toupper(i8 signext %628)
%630 = sext i8 %629 to i32
%631 = icmp eq i32 %630, 84
br i1 %631, label %656, label %632
632: ; preds = %624, %608
%633 = load i8*, i8** %40
%634 = load i64, i64* %77
%635 = getelementptr inbounds i8, i8* %633, i64 %634
%636 = load i8, i8* %635
%637 = call signext i8 @toupper(i8 signext %636)
%638 = sext i8 %637 to i32
%639 = icmp eq i32 %638, 65
br i1 %639, label %640, label %659
640: ; preds = %632
%641 = load i8*, i8** %40
%642 = load i64, i64* %75
%643 = getelementptr inbounds i8, i8* %641, i64 %642
%644 = load i8, i8* %643
%645 = call signext i8 @toupper(i8 signext %644)
%646 = sext i8 %645 to i32
%647 = icmp eq i32 %646, 85
br i1 %647, label %656, label %648
648: ; preds = %640
%649 = load i8*, i8** %40
%650 = load i64, i64* %75
%651 = getelementptr inbounds i8, i8* %649, i64 %650
%652 = load i8, i8* %651
%653 = call signext i8 @toupper(i8 signext %652)
%654 = sext i8 %653 to i32
%655 = icmp eq i32 %654, 84
br i1 %655, label %656, label %659
656: ; preds = %648, %640, %624, %616
%657 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%658 = call i32 @strcpy(i8* %657, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0))
br label %698
659: ; preds = %648, %632
%660 = load i8*, i8** %40
%661 = load i64, i64* %75
%662 = getelementptr inbounds i8, i8* %660, i64 %661
%663 = load i8, i8* %662
%664 = call signext i8 @toupper(i8 signext %663)
%665 = sext i8 %664 to i32
%666 = icmp eq i32 %665, 71
br i1 %666, label %667, label %675
667: ; preds = %659
%668 = load i8*, i8** %40
%669 = load i64, i64* %77
%670 = getelementptr inbounds i8, i8* %668, i64 %669
%671 = load i8, i8* %670
%672 = call signext i8 @toupper(i8 signext %671)
%673 = sext i8 %672 to i32
%674 = icmp eq i32 %673, 67
br i1 %674, label %691, label %675
675: ; preds = %667, %659
%676 = load i8*, i8** %40
%677 = load i64, i64* %77
%678 = getelementptr inbounds i8, i8* %676, i64 %677
%679 = load i8, i8* %678
%680 = call signext i8 @toupper(i8 signext %679)
%681 = sext i8 %680 to i32
%682 = icmp eq i32 %681, 71
br i1 %682, label %683, label %694
683: ; preds = %675
%684 = load i8*, i8** %40
%685 = load i64, i64* %75
%686 = getelementptr inbounds i8, i8* %684, i64 %685
%687 = load i8, i8* %686
%688 = call signext i8 @toupper(i8 signext %687)
%689 = sext i8 %688 to i32
%690 = icmp eq i32 %689, 67
br i1 %690, label %691, label %694
691: ; preds = %683, %667
%692 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%693 = call i32 @strcpy(i8* %692, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.11, i64 0, i64 0))
br label %697
694: ; preds = %683, %675
%695 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%696 = call i32 @strcpy(i8* %695, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i64 0, i64 0))
br label %697
697: ; preds = %694, %691
br label %698
698: ; preds = %697, %656
br label %753
699: ; preds = %605
%700 = load i64, i64* %74
%701 = icmp eq i64 %700, 1
br i1 %701, label %705, label %702
702: ; preds = %699
%703 = load i64, i64* %74
%704 = icmp eq i64 %703, -1
br i1 %704, label %705, label %752
705: ; preds = %702, %699
store double 4.100000e+00, double* %94
%706 = load i64, i64* %75
%707 = load i64, i64* %77
%708 = load double, double* %94
%709 = load i64**, i64*** %33
%710 = load i8**, i8*** %35
%711 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%712 = load double**, double*** %34
%713 = load i8*, i8** %40
%714 = load i8**, i8*** %58
%715 = load i8**, i8*** %59
%716 = load double*, double** %92
%717 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%718 = call i32 @LW_pair_type(i64 %706, i64 %707, double %708, i64** %709, i8** %710, i8* %711, double** %712, i8* %713, i8** %714, i8** %715, double* %716, i8* %717)
%719 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%720 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%721 = load i8, i8* %720
%722 = sext i8 %721 to i32
%723 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 2
%724 = load i8, i8* %723
%725 = sext i8 %724 to i32
%726 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 4
%727 = load i8, i8* %726
%728 = sext i8 %727 to i32
%729 = call i32 (i8*, i8*, ...) @sprintf(i8* %719, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %722, i32 %725, i32 %728)
%730 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%731 = call i64 @strstr(i8* %730, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%732 = icmp ne i64 %731, 0
br i1 %732, label %737, label %733
733: ; preds = %705
%734 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%735 = call i64 @strstr(i8* %734, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%736 = icmp ne i64 %735, 0
br i1 %736, label %737, label %751
737: ; preds = %733, %705
store double 4.300000e+00, double* %94
%738 = load i64, i64* %75
%739 = load i64, i64* %77
%740 = load double, double* %94
%741 = load i64**, i64*** %33
%742 = load i8**, i8*** %35
%743 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%744 = load double**, double*** %34
%745 = load i8*, i8** %40
%746 = load i8**, i8*** %58
%747 = load i8**, i8*** %59
%748 = load double*, double** %92
%749 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%750 = call i32 @LW_pair_type(i64 %738, i64 %739, double %740, i64** %741, i8** %742, i8* %743, double** %744, i8* %745, i8** %746, i8** %747, double* %748, i8* %749)
br label %751
751: ; preds = %737, %733
br label %752
752: ; preds = %751, %702
br label %753
753: ; preds = %752, %698
br label %754
754: ; preds = %753, %604
%755 = load i8*, i8** %40
%756 = load i64, i64* %75
%757 = getelementptr inbounds i8, i8* %755, i64 %756
%758 = load i8, i8* %757
%759 = load i8*, i8** %40
%760 = load i64, i64* %77
%761 = getelementptr inbounds i8, i8* %759, i64 %760
%762 = load i8, i8* %761
%763 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%764 = getelementptr inbounds [20 x i8], [20 x i8]* %52, i64 0, i64 0
%765 = call i32 @LW_Saenger_correspond(i8 signext %758, i8 signext %762, i8* %763, i8* %764)
%766 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%767 = call signext i8 @ConvertState(i8* %766)
%768 = load i8*, i8** %95
%769 = load i64, i64* %75
%770 = sub nsw i64 %769, 1
%771 = getelementptr inbounds i8, i8* %768, i64 %770
store i8 %767, i8* %771
%772 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%773 = call signext i8 @ConvertState(i8* %772)
%774 = load i8*, i8** %95
%775 = load i64, i64* %77
%776 = sub nsw i64 %775, 1
%777 = getelementptr inbounds i8, i8* %774, i64 %776
store i8 %773, i8* %777
%778 = load i64, i64* %80
%779 = add nsw i64 %778, 1
store i64 %779, i64* %80
%780 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%781 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%782 = load i8, i8* %781
%783 = sext i8 %782 to i32
%784 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 2
%785 = load i8, i8* %784
%786 = sext i8 %785 to i32
%787 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 4
%788 = load i8, i8* %787
%789 = sext i8 %788 to i32
%790 = call i32 (i8*, i8*, ...) @sprintf(i8* %780, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %783, i32 %786, i32 %789)
%791 = load i8**, i8*** %42
%792 = load i64, i64* %80
%793 = getelementptr inbounds i8*, i8** %791, i64 %792
%794 = load i8*, i8** %793
%795 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%796 = call i32 @strcpy(i8* %794, i8* %795)
%797 = load i64, i64* %80
%798 = load i64, i64* %27
%799 = mul nsw i64 2, %798
%800 = icmp sge i64 %797, %799
br i1 %800, label %801, label %802
801: ; preds = %754
store i8* null, i8** %25
br label %1450
802: ; preds = %754
%803 = load i64, i64* %75
%804 = load i64**, i64*** %43
%805 = load i64, i64* %80
%806 = getelementptr inbounds i64*, i64** %804, i64 %805
%807 = load i64*, i64** %806
%808 = getelementptr inbounds i64, i64* %807, i64 1
store i64 %803, i64* %808
%809 = load i64, i64* %77
%810 = load i64**, i64*** %43
%811 = load i64, i64* %80
%812 = getelementptr inbounds i64*, i64** %810, i64 %811
%813 = load i64*, i64** %812
%814 = getelementptr inbounds i64, i64* %813, i64 2
store i64 %809, i64* %814
br label %815
815: ; preds = %802
%816 = load i64**, i64*** %85
%817 = load i64, i64* %75
%818 = getelementptr inbounds i64*, i64** %816, i64 %817
%819 = load i64*, i64** %818
%820 = getelementptr inbounds i64, i64* %819, i64 101
%821 = load i64, i64* %820
%822 = add nsw i64 %821, 1
store i64 %822, i64* %820
%823 = icmp sge i64 %822, 101
br i1 %823, label %824, label %832
824: ; preds = %815
%825 = load i64**, i64*** %85
%826 = load i64, i64* %75
%827 = getelementptr inbounds i64*, i64** %825, i64 %826
%828 = load i64*, i64** %827
%829 = getelementptr inbounds i64, i64* %828, i64 101
%830 = load i64, i64* %829
%831 = add nsw i64 %830, -1
store i64 %831, i64* %829
br label %1395
832: ; preds = %815
%833 = load i64, i64* %77
%834 = load i64**, i64*** %85
%835 = load i64, i64* %75
%836 = getelementptr inbounds i64*, i64** %834, i64 %835
%837 = load i64*, i64** %836
%838 = load i64**, i64*** %85
%839 = load i64, i64* %75
%840 = getelementptr inbounds i64*, i64** %838, i64 %839
%841 = load i64*, i64** %840
%842 = getelementptr inbounds i64, i64* %841, i64 101
%843 = load i64, i64* %842
%844 = getelementptr inbounds i64, i64* %837, i64 %843
store i64 %833, i64* %844
br label %845
845: ; preds = %832
%846 = load i64**, i64*** %85
%847 = load i64, i64* %77
%848 = getelementptr inbounds i64*, i64** %846, i64 %847
%849 = load i64*, i64** %848
%850 = getelementptr inbounds i64, i64* %849, i64 101
%851 = load i64, i64* %850
%852 = add nsw i64 %851, 1
store i64 %852, i64* %850
%853 = icmp sge i64 %852, 101
br i1 %853, label %854, label %862
854: ; preds = %845
%855 = load i64**, i64*** %85
%856 = load i64, i64* %77
%857 = getelementptr inbounds i64*, i64** %855, i64 %856
%858 = load i64*, i64** %857
%859 = getelementptr inbounds i64, i64* %858, i64 101
%860 = load i64, i64* %859
%861 = add nsw i64 %860, -1
store i64 %861, i64* %859
br label %1395
862: ; preds = %845
%863 = load i64, i64* %75
%864 = load i64**, i64*** %85
%865 = load i64, i64* %77
%866 = getelementptr inbounds i64*, i64** %864, i64 %865
%867 = load i64*, i64** %866
%868 = load i64**, i64*** %85
%869 = load i64, i64* %77
%870 = getelementptr inbounds i64*, i64** %868, i64 %869
%871 = load i64*, i64** %870
%872 = getelementptr inbounds i64, i64* %871, i64 101
%873 = load i64, i64* %872
%874 = getelementptr inbounds i64, i64* %867, i64 %873
store i64 %863, i64* %874
br label %875
875: ; preds = %862
br label %1391
876: ; preds = %248
%877 = load i64, i64* %74
%878 = icmp eq i64 %877, 0
br i1 %878, label %879, label %1390
879: ; preds = %876
%880 = load i64**, i64*** %33
%881 = load i64, i64* %75
%882 = getelementptr inbounds i64*, i64** %880, i64 %881
%883 = load i64*, i64** %882
%884 = getelementptr inbounds i64, i64* %883, i64 1
%885 = load i64, i64* %884
store i64 %885, i64* %76
%886 = load i64**, i64*** %33
%887 = load i64, i64* %77
%888 = getelementptr inbounds i64*, i64** %886, i64 %887
%889 = load i64*, i64** %888
%890 = getelementptr inbounds i64, i64* %889, i64 1
%891 = load i64, i64* %890
store i64 %891, i64* %78
%892 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%893 = load i64, i64* %75
%894 = load i64, i64* %77
%895 = call i32 (i8*, i8*, ...) @sprintf(i8* %892, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i64 %893, i64 %894)
%896 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 1
%897 = load double, double* %896
%898 = load double*, double** %32
%899 = getelementptr inbounds double, double* %898, i64 2
%900 = load double, double* %899
%901 = fcmp ogt double %897, %900
br i1 %901, label %902, label %903
902: ; preds = %879
br label %1392
903: ; preds = %879
%904 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 2
%905 = load double, double* %904
%906 = load double*, double** %32
%907 = getelementptr inbounds double, double* %906, i64 3
%908 = load double, double* %907
%909 = fadd double %908, 3.000000e-01
%910 = fcmp ogt double %905, %909
br i1 %910, label %911, label %912
911: ; preds = %903
br label %1392
912: ; preds = %903
%913 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 3
%914 = load double, double* %913
%915 = load double*, double** %32
%916 = getelementptr inbounds double, double* %915, i64 4
%917 = load double, double* %916
%918 = fcmp ogt double %914, %917
br i1 %918, label %919, label %920
919: ; preds = %912
br label %1392
920: ; preds = %912
%921 = load i64, i64* %75
%922 = load i64, i64* %77
%923 = load i8*, i8** %40
%924 = load i64**, i64*** %33
%925 = load i8**, i8*** %35
%926 = load double**, double*** %34
%927 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 0
%928 = call i32 @base_stack(i64 %921, i64 %922, i8* %923, i64** %924, i8** %925, double** %926, double* %927, i64* %82)
%929 = load i64, i64* %82
%930 = icmp sgt i64 %929, 0
br i1 %930, label %931, label %947
931: ; preds = %920
%932 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 3
%933 = load double, double* %932
%934 = fcmp olt double %933, 4.000000e+01
br i1 %934, label %935, label %946
935: ; preds = %931
%936 = call signext i8 @ConvertState(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%937 = load i8*, i8** %95
%938 = load i64, i64* %75
%939 = sub nsw i64 %938, 1
%940 = getelementptr inbounds i8, i8* %937, i64 %939
store i8 %936, i8* %940
%941 = call signext i8 @ConvertState(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%942 = load i8*, i8** %95
%943 = load i64, i64* %77
%944 = sub nsw i64 %943, 1
%945 = getelementptr inbounds i8, i8* %942, i64 %944
store i8 %941, i8* %945
br label %946
946: ; preds = %935, %931
br label %1392
947: ; preds = %920
%948 = getelementptr inbounds [21 x double], [21 x double]* %90, i64 0, i64 2
%949 = load double, double* %948
%950 = load double*, double** %32
%951 = getelementptr inbounds double, double* %950, i64 3
%952 = load double, double* %951
%953 = fcmp ogt double %949, %952
br i1 %953, label %954, label %955
954: ; preds = %947
br label %1392
955: ; preds = %947
store i64 0, i64* %83
store i64 1, i64* %84
store double 0.000000e+00, double* %93
%956 = load i64, i64* %75
%957 = load i64, i64* %77
%958 = load i64**, i64*** %33
%959 = load i8**, i8*** %35
%960 = load i8*, i8** %40
%961 = load double**, double*** %34
%962 = load double, double* %93
%963 = load i8**, i8*** %58
%964 = load i8**, i8*** %59
%965 = load double*, double** %92
%966 = load i64, i64* %83
%967 = load i64, i64* %84
%968 = call i32 @Hbond_pair(i64 %956, i64 %957, i64** %958, i8** %959, i8* %960, double** %961, double %962, i64* %81, i8** %963, i8** %964, double* %965, i64 %966, i64 %967)
%969 = load i64, i64* %81
%970 = icmp sgt i64 %969, 0
br i1 %970, label %971, label %1389
971: ; preds = %955
store i64 0, i64* %72
store i64 0, i64* %73
store i64 1, i64* %79
br label %972
972: ; preds = %1130, %971
%973 = load i64, i64* %79
%974 = load i64, i64* %81
%975 = icmp sle i64 %973, %974
br i1 %975, label %976, label %1133
976: ; preds = %972
%977 = load i8**, i8*** %58
%978 = load i64, i64* %79
%979 = getelementptr inbounds i8*, i8** %977, i64 %978
%980 = load i8*, i8** %979
%981 = call i32 @strcmp(i8* %980, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%982 = icmp ne i32 %981, 0
br i1 %982, label %983, label %990
983: ; preds = %976
%984 = load i8**, i8*** %58
%985 = load i64, i64* %79
%986 = getelementptr inbounds i8*, i8** %984, i64 %985
%987 = load i8*, i8** %986
%988 = call i32 @strcmp(i8* %987, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%989 = icmp ne i32 %988, 0
br i1 %989, label %1017, label %990
990: ; preds = %983, %976
%991 = load i8**, i8*** %59
%992 = load i64, i64* %79
%993 = getelementptr inbounds i8*, i8** %991, i64 %992
%994 = load i8*, i8** %993
%995 = getelementptr inbounds i8, i8* %994, i64 1
%996 = load i8, i8* %995
%997 = call i64 @strchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0), i8 signext %996)
%998 = icmp ne i64 %997, 0
br i1 %998, label %999, label %1017
999: ; preds = %990
%1000 = load i8**, i8*** %59
%1001 = load i64, i64* %79
%1002 = getelementptr inbounds i8*, i8** %1000, i64 %1001
%1003 = load i8*, i8** %1002
%1004 = getelementptr inbounds i8, i8* %1003, i64 3
%1005 = load i8, i8* %1004
%1006 = sext i8 %1005 to i32
%1007 = icmp ne i32 %1006, 39
br i1 %1007, label %1008, label %1017
1008: ; preds = %999
%1009 = load i8**, i8*** %59
%1010 = load i64, i64* %79
%1011 = getelementptr inbounds i8*, i8** %1009, i64 %1010
%1012 = load i8*, i8** %1011
%1013 = getelementptr inbounds i8, i8* %1012, i64 3
%1014 = load i8, i8* %1013
%1015 = sext i8 %1014 to i32
%1016 = icmp ne i32 %1015, 80
br i1 %1016, label %1058, label %1017
1017: ; preds = %1008, %999, %990, %983
%1018 = load i8**, i8*** %59
%1019 = load i64, i64* %79
%1020 = getelementptr inbounds i8*, i8** %1018, i64 %1019
%1021 = load i8*, i8** %1020
%1022 = call i32 @strcmp(i8* %1021, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%1023 = icmp ne i32 %1022, 0
br i1 %1023, label %1024, label %1031
1024: ; preds = %1017
%1025 = load i8**, i8*** %59
%1026 = load i64, i64* %79
%1027 = getelementptr inbounds i8*, i8** %1025, i64 %1026
%1028 = load i8*, i8** %1027
%1029 = call i32 @strcmp(i8* %1028, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%1030 = icmp ne i32 %1029, 0
br i1 %1030, label %1061, label %1031
1031: ; preds = %1024, %1017
%1032 = load i8**, i8*** %58
%1033 = load i64, i64* %79
%1034 = getelementptr inbounds i8*, i8** %1032, i64 %1033
%1035 = load i8*, i8** %1034
%1036 = getelementptr inbounds i8, i8* %1035, i64 1
%1037 = load i8, i8* %1036
%1038 = call i64 @strchr(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0), i8 signext %1037)
%1039 = icmp ne i64 %1038, 0
br i1 %1039, label %1040, label %1061
1040: ; preds = %1031
%1041 = load i8**, i8*** %58
%1042 = load i64, i64* %79
%1043 = getelementptr inbounds i8*, i8** %1041, i64 %1042
%1044 = load i8*, i8** %1043
%1045 = getelementptr inbounds i8, i8* %1044, i64 3
%1046 = load i8, i8* %1045
%1047 = sext i8 %1046 to i32
%1048 = icmp ne i32 %1047, 39
br i1 %1048, label %1049, label %1061
1049: ; preds = %1040
%1050 = load i8**, i8*** %58
%1051 = load i64, i64* %79
%1052 = getelementptr inbounds i8*, i8** %1050, i64 %1051
%1053 = load i8*, i8** %1052
%1054 = getelementptr inbounds i8, i8* %1053, i64 3
%1055 = load i8, i8* %1054
%1056 = sext i8 %1055 to i32
%1057 = icmp ne i32 %1056, 80
br i1 %1057, label %1058, label %1061
1058: ; preds = %1049, %1008
%1059 = load i64, i64* %72
%1060 = add nsw i64 %1059, 1
store i64 %1060, i64* %72
br label %1129
1061: ; preds = %1049, %1040, %1031, %1024
%1062 = load i8**, i8*** %58
%1063 = load i64, i64* %79
%1064 = getelementptr inbounds i8*, i8** %1062, i64 %1063
%1065 = load i8*, i8** %1064
%1066 = call i32 @strcmp(i8* %1065, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%1067 = icmp ne i32 %1066, 0
br i1 %1067, label %1068, label %1075
1068: ; preds = %1061
%1069 = load i8**, i8*** %58
%1070 = load i64, i64* %79
%1071 = getelementptr inbounds i8*, i8** %1069, i64 %1070
%1072 = load i8*, i8** %1071
%1073 = call i32 @strcmp(i8* %1072, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%1074 = icmp ne i32 %1073, 0
br i1 %1074, label %1093, label %1075
1075: ; preds = %1068, %1061
%1076 = load i8**, i8*** %59
%1077 = load i64, i64* %79
%1078 = getelementptr inbounds i8*, i8** %1076, i64 %1077
%1079 = load i8*, i8** %1078
%1080 = getelementptr inbounds i8, i8* %1079, i64 3
%1081 = load i8, i8* %1080
%1082 = sext i8 %1081 to i32
%1083 = icmp ne i32 %1082, 39
br i1 %1083, label %1084, label %1093
1084: ; preds = %1075
%1085 = load i8**, i8*** %59
%1086 = load i64, i64* %79
%1087 = getelementptr inbounds i8*, i8** %1085, i64 %1086
%1088 = load i8*, i8** %1087
%1089 = getelementptr inbounds i8, i8* %1088, i64 1
%1090 = load i8, i8* %1089
%1091 = sext i8 %1090 to i32
%1092 = icmp ne i32 %1091, 67
br i1 %1092, label %1125, label %1093
1093: ; preds = %1084, %1075, %1068
%1094 = load i8**, i8*** %59
%1095 = load i64, i64* %79
%1096 = getelementptr inbounds i8*, i8** %1094, i64 %1095
%1097 = load i8*, i8** %1096
%1098 = call i32 @strcmp(i8* %1097, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%1099 = icmp ne i32 %1098, 0
br i1 %1099, label %1100, label %1107
1100: ; preds = %1093
%1101 = load i8**, i8*** %59
%1102 = load i64, i64* %79
%1103 = getelementptr inbounds i8*, i8** %1101, i64 %1102
%1104 = load i8*, i8** %1103
%1105 = call i32 @strcmp(i8* %1104, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%1106 = icmp ne i32 %1105, 0
br i1 %1106, label %1128, label %1107
1107: ; preds = %1100, %1093
%1108 = load i8**, i8*** %58
%1109 = load i64, i64* %79
%1110 = getelementptr inbounds i8*, i8** %1108, i64 %1109
%1111 = load i8*, i8** %1110
%1112 = getelementptr inbounds i8, i8* %1111, i64 3
%1113 = load i8, i8* %1112
%1114 = sext i8 %1113 to i32
%1115 = icmp ne i32 %1114, 39
br i1 %1115, label %1116, label %1128
1116: ; preds = %1107
%1117 = load i8**, i8*** %58
%1118 = load i64, i64* %79
%1119 = getelementptr inbounds i8*, i8** %1117, i64 %1118
%1120 = load i8*, i8** %1119
%1121 = getelementptr inbounds i8, i8* %1120, i64 1
%1122 = load i8, i8* %1121
%1123 = sext i8 %1122 to i32
%1124 = icmp ne i32 %1123, 67
br i1 %1124, label %1125, label %1128
1125: ; preds = %1116, %1084
%1126 = load i64, i64* %73
%1127 = add nsw i64 %1126, 1
store i64 %1127, i64* %73
br label %1128
1128: ; preds = %1125, %1116, %1107, %1100
br label %1129
1129: ; preds = %1128, %1058
br label %1130
1130: ; preds = %1129
%1131 = load i64, i64* %79
%1132 = add nsw i64 %1131, 1
store i64 %1132, i64* %79
br label %972
1133: ; preds = %972
%1134 = load i64, i64* %81
%1135 = load i64, i64* %72
%1136 = icmp eq i64 %1134, %1135
br i1 %1136, label %1137, label %1219
1137: ; preds = %1133
%1138 = load i64, i64* %69
%1139 = add nsw i64 %1138, 1
store i64 %1139, i64* %69
%1140 = load i64, i64* %27
%1141 = sub nsw i64 %1140, 2
%1142 = icmp sgt i64 %1138, %1141
br i1 %1142, label %1143, label %1144
1143: ; preds = %1137
store i8* null, i8** %25
br label %1450
1144: ; preds = %1137
store double 4.800000e+00, double* %94
%1145 = load i64, i64* %75
%1146 = load i64, i64* %77
%1147 = load double, double* %94
%1148 = load i64**, i64*** %33
%1149 = load i8**, i8*** %35
%1150 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1151 = load double**, double*** %34
%1152 = load i8*, i8** %40
%1153 = load i8**, i8*** %58
%1154 = load i8**, i8*** %59
%1155 = load double*, double** %92
%1156 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1157 = call i32 @LW_pair_type(i64 %1145, i64 %1146, double %1147, i64** %1148, i8** %1149, i8* %1150, double** %1151, i8* %1152, i8** %1153, i8** %1154, double* %1155, i8* %1156)
%1158 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1159 = call i64 @strstr(i8* %1158, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%1160 = icmp ne i64 %1159, 0
br i1 %1160, label %1165, label %1161
1161: ; preds = %1144
%1162 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1163 = call i64 @strstr(i8* %1162, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%1164 = icmp ne i64 %1163, 0
br i1 %1164, label %1165, label %1179
1165: ; preds = %1161, %1144
store double 5.800000e+00, double* %94
%1166 = load i64, i64* %75
%1167 = load i64, i64* %77
%1168 = load double, double* %94
%1169 = load i64**, i64*** %33
%1170 = load i8**, i8*** %35
%1171 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1172 = load double**, double*** %34
%1173 = load i8*, i8** %40
%1174 = load i8**, i8*** %58
%1175 = load i8**, i8*** %59
%1176 = load double*, double** %92
%1177 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1178 = call i32 @LW_pair_type(i64 %1166, i64 %1167, double %1168, i64** %1169, i8** %1170, i8* %1171, double** %1172, i8* %1173, i8** %1174, i8** %1175, double* %1176, i8* %1177)
br label %1179
1179: ; preds = %1165, %1161
%1180 = load i8**, i8*** %65
%1181 = load i64, i64* %69
%1182 = getelementptr inbounds i8*, i8** %1180, i64 %1181
%1183 = load i8*, i8** %1182
%1184 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%1185 = load i8*, i8** %37
%1186 = load i64, i64* %76
%1187 = getelementptr inbounds i8, i8* %1185, i64 %1186
%1188 = load i8, i8* %1187
%1189 = sext i8 %1188 to i32
%1190 = load i64*, i64** %38
%1191 = load i64, i64* %76
%1192 = getelementptr inbounds i64, i64* %1190, i64 %1191
%1193 = load i64, i64* %1192
%1194 = load i8*, i8** %40
%1195 = load i64, i64* %75
%1196 = getelementptr inbounds i8, i8* %1194, i64 %1195
%1197 = load i8, i8* %1196
%1198 = sext i8 %1197 to i32
%1199 = load i8*, i8** %40
%1200 = load i64, i64* %77
%1201 = getelementptr inbounds i8, i8* %1199, i64 %1200
%1202 = load i8, i8* %1201
%1203 = sext i8 %1202 to i32
%1204 = load i64*, i64** %38
%1205 = load i64, i64* %78
%1206 = getelementptr inbounds i64, i64* %1204, i64 %1205
%1207 = load i64, i64* %1206
%1208 = load i8*, i8** %37
%1209 = load i64, i64* %78
%1210 = getelementptr inbounds i8, i8* %1208, i64 %1209
%1211 = load i8, i8* %1210
%1212 = sext i8 %1211 to i32
%1213 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1214 = load i8, i8* %51
%1215 = sext i8 %1214 to i32
%1216 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%1217 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%1218 = call i32 (i8*, i8*, ...) @sprintf(i8* %1183, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.19, i64 0, i64 0), i8* %1184, i32 %1189, i64 %1193, i32 %1198, i32 %1203, i64 %1207, i32 %1212, i8* %1213, i32 %1215, i8* %1216, i8* %1217)
br label %1388
1219: ; preds = %1133
%1220 = load i64, i64* %81
%1221 = load i64, i64* %73
%1222 = icmp eq i64 %1220, %1221
br i1 %1222, label %1223, label %1305
1223: ; preds = %1219
%1224 = load i64, i64* %70
%1225 = add nsw i64 %1224, 1
store i64 %1225, i64* %70
%1226 = load i64, i64* %27
%1227 = sub nsw i64 %1226, 2
%1228 = icmp sgt i64 %1224, %1227
br i1 %1228, label %1229, label %1230
1229: ; preds = %1223
store i8* null, i8** %25
br label %1450
1230: ; preds = %1223
store double 4.800000e+00, double* %94
%1231 = load i64, i64* %75
%1232 = load i64, i64* %77
%1233 = load double, double* %94
%1234 = load i64**, i64*** %33
%1235 = load i8**, i8*** %35
%1236 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1237 = load double**, double*** %34
%1238 = load i8*, i8** %40
%1239 = load i8**, i8*** %58
%1240 = load i8**, i8*** %59
%1241 = load double*, double** %92
%1242 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1243 = call i32 @LW_pair_type(i64 %1231, i64 %1232, double %1233, i64** %1234, i8** %1235, i8* %1236, double** %1237, i8* %1238, i8** %1239, i8** %1240, double* %1241, i8* %1242)
%1244 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1245 = call i64 @strstr(i8* %1244, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%1246 = icmp ne i64 %1245, 0
br i1 %1246, label %1251, label %1247
1247: ; preds = %1230
%1248 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1249 = call i64 @strstr(i8* %1248, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%1250 = icmp ne i64 %1249, 0
br i1 %1250, label %1251, label %1265
1251: ; preds = %1247, %1230
store double 5.800000e+00, double* %94
%1252 = load i64, i64* %75
%1253 = load i64, i64* %77
%1254 = load double, double* %94
%1255 = load i64**, i64*** %33
%1256 = load i8**, i8*** %35
%1257 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1258 = load double**, double*** %34
%1259 = load i8*, i8** %40
%1260 = load i8**, i8*** %58
%1261 = load i8**, i8*** %59
%1262 = load double*, double** %92
%1263 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1264 = call i32 @LW_pair_type(i64 %1252, i64 %1253, double %1254, i64** %1255, i8** %1256, i8* %1257, double** %1258, i8* %1259, i8** %1260, i8** %1261, double* %1262, i8* %1263)
br label %1265
1265: ; preds = %1251, %1247
%1266 = load i8**, i8*** %66
%1267 = load i64, i64* %70
%1268 = getelementptr inbounds i8*, i8** %1266, i64 %1267
%1269 = load i8*, i8** %1268
%1270 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%1271 = load i8*, i8** %37
%1272 = load i64, i64* %76
%1273 = getelementptr inbounds i8, i8* %1271, i64 %1272
%1274 = load i8, i8* %1273
%1275 = sext i8 %1274 to i32
%1276 = load i64*, i64** %38
%1277 = load i64, i64* %76
%1278 = getelementptr inbounds i64, i64* %1276, i64 %1277
%1279 = load i64, i64* %1278
%1280 = load i8*, i8** %40
%1281 = load i64, i64* %75
%1282 = getelementptr inbounds i8, i8* %1280, i64 %1281
%1283 = load i8, i8* %1282
%1284 = sext i8 %1283 to i32
%1285 = load i8*, i8** %40
%1286 = load i64, i64* %77
%1287 = getelementptr inbounds i8, i8* %1285, i64 %1286
%1288 = load i8, i8* %1287
%1289 = sext i8 %1288 to i32
%1290 = load i64*, i64** %38
%1291 = load i64, i64* %78
%1292 = getelementptr inbounds i64, i64* %1290, i64 %1291
%1293 = load i64, i64* %1292
%1294 = load i8*, i8** %37
%1295 = load i64, i64* %78
%1296 = getelementptr inbounds i8, i8* %1294, i64 %1295
%1297 = load i8, i8* %1296
%1298 = sext i8 %1297 to i32
%1299 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1300 = load i8, i8* %51
%1301 = sext i8 %1300 to i32
%1302 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%1303 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%1304 = call i32 (i8*, i8*, ...) @sprintf(i8* %1269, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.20, i64 0, i64 0), i8* %1270, i32 %1275, i64 %1279, i32 %1284, i32 %1289, i64 %1293, i32 %1298, i8* %1299, i32 %1301, i8* %1302, i8* %1303)
br label %1387
1305: ; preds = %1219
%1306 = load i64, i64* %71
%1307 = add nsw i64 %1306, 1
store i64 %1307, i64* %71
%1308 = load i64, i64* %27
%1309 = sub nsw i64 %1308, 2
%1310 = icmp sgt i64 %1306, %1309
br i1 %1310, label %1311, label %1312
1311: ; preds = %1305
store i8* null, i8** %25
br label %1450
1312: ; preds = %1305
store double 5.200000e+00, double* %94
%1313 = load i64, i64* %75
%1314 = load i64, i64* %77
%1315 = load double, double* %94
%1316 = load i64**, i64*** %33
%1317 = load i8**, i8*** %35
%1318 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1319 = load double**, double*** %34
%1320 = load i8*, i8** %40
%1321 = load i8**, i8*** %58
%1322 = load i8**, i8*** %59
%1323 = load double*, double** %92
%1324 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1325 = call i32 @LW_pair_type(i64 %1313, i64 %1314, double %1315, i64** %1316, i8** %1317, i8* %1318, double** %1319, i8* %1320, i8** %1321, i8** %1322, double* %1323, i8* %1324)
%1326 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1327 = call i64 @strstr(i8* %1326, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%1328 = icmp ne i64 %1327, 0
br i1 %1328, label %1333, label %1329
1329: ; preds = %1312
%1330 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 0
%1331 = call i64 @strstr(i8* %1330, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%1332 = icmp ne i64 %1331, 0
br i1 %1332, label %1333, label %1347
1333: ; preds = %1329, %1312
store double 6.000000e+00, double* %94
%1334 = load i64, i64* %75
%1335 = load i64, i64* %77
%1336 = load double, double* %94
%1337 = load i64**, i64*** %33
%1338 = load i8**, i8*** %35
%1339 = getelementptr inbounds [512 x i8], [512 x i8]* %50, i64 0, i64 0
%1340 = load double**, double*** %34
%1341 = load i8*, i8** %40
%1342 = load i8**, i8*** %58
%1343 = load i8**, i8*** %59
%1344 = load double*, double** %92
%1345 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1346 = call i32 @LW_pair_type(i64 %1334, i64 %1335, double %1336, i64** %1337, i8** %1338, i8* %1339, double** %1340, i8* %1341, i8** %1342, i8** %1343, double* %1344, i8* %1345)
br label %1347
1347: ; preds = %1333, %1329
%1348 = load i8**, i8*** %67
%1349 = load i64, i64* %71
%1350 = getelementptr inbounds i8*, i8** %1348, i64 %1349
%1351 = load i8*, i8** %1350
%1352 = getelementptr inbounds [20 x i8], [20 x i8]* %56, i64 0, i64 0
%1353 = load i8*, i8** %37
%1354 = load i64, i64* %76
%1355 = getelementptr inbounds i8, i8* %1353, i64 %1354
%1356 = load i8, i8* %1355
%1357 = sext i8 %1356 to i32
%1358 = load i64*, i64** %38
%1359 = load i64, i64* %76
%1360 = getelementptr inbounds i64, i64* %1358, i64 %1359
%1361 = load i64, i64* %1360
%1362 = load i8*, i8** %40
%1363 = load i64, i64* %75
%1364 = getelementptr inbounds i8, i8* %1362, i64 %1363
%1365 = load i8, i8* %1364
%1366 = sext i8 %1365 to i32
%1367 = load i8*, i8** %40
%1368 = load i64, i64* %77
%1369 = getelementptr inbounds i8, i8* %1367, i64 %1368
%1370 = load i8, i8* %1369
%1371 = sext i8 %1370 to i32
%1372 = load i64*, i64** %38
%1373 = load i64, i64* %78
%1374 = getelementptr inbounds i64, i64* %1372, i64 %1373
%1375 = load i64, i64* %1374
%1376 = load i8*, i8** %37
%1377 = load i64, i64* %78
%1378 = getelementptr inbounds i8, i8* %1376, i64 %1377
%1379 = load i8, i8* %1378
%1380 = sext i8 %1379 to i32
%1381 = getelementptr inbounds [20 x i8], [20 x i8]* %60, i64 0, i64 0
%1382 = load i8, i8* %51
%1383 = sext i8 %1382 to i32
%1384 = getelementptr inbounds [20 x i8], [20 x i8]* %61, i64 0, i64 0
%1385 = getelementptr inbounds [20 x i8], [20 x i8]* %62, i64 0, i64 0
%1386 = call i32 (i8*, i8*, ...) @sprintf(i8* %1351, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.21, i64 0, i64 0), i8* %1352, i32 %1357, i64 %1361, i32 %1366, i32 %1371, i64 %1375, i32 %1380, i8* %1381, i32 %1383, i8* %1384, i8* %1385)
br label %1387
1387: ; preds = %1347, %1265
br label %1388
1388: ; preds = %1387, %1179
br label %1389
1389: ; preds = %1388, %955
br label %1390
1390: ; preds = %1389, %876
br label %1391
1391: ; preds = %1390, %875
br label %1392
1392: ; preds = %1391, %954, %946, %919, %911, %902, %548, %437, %332
%1393 = load i64, i64* %77
%1394 = add nsw i64 %1393, 1
store i64 %1394, i64* %77
br label %208
1395: ; preds = %854, %824, %208
br label %1396
1396: ; preds = %1395
%1397 = load i64, i64* %75
%1398 = add nsw i64 %1397, 1
store i64 %1398, i64* %75
br label %201
1399: ; preds = %201
%1400 = load i64, i64* %80
%1401 = load i64*, i64** %41
store i64 %1400, i64* %1401
%1402 = load i64, i64* %27
%1403 = load i64*, i64** %28
%1404 = load i64**, i64*** %33
%1405 = load i8**, i8*** %35
%1406 = load i8**, i8*** %36
%1407 = load i8*, i8** %37
%1408 = load i64*, i64** %38
%1409 = load i8**, i8*** %39
%1410 = load double**, double*** %34
%1411 = load i8*, i8** %40
%1412 = load i64**, i64*** %85
%1413 = load double**, double*** %29
%1414 = load double**, double*** %30
%1415 = load double**, double*** %31
%1416 = load double*, double** %32
%1417 = load i64*, i64** %46
%1418 = load i64*, i64** %47
%1419 = load i64**, i64*** %48
%1420 = call i32 @bp_network(i64 %1402, i64* %1403, i64** %1404, i8** %1405, i8** %1406, i8* %1407, i64* %1408, i8** %1409, double** %1410, i8* %1411, i64** %1412, double** %1413, double** %1414, double** %1415, double* %1416, i64* %1417, i64* %1418, i64** %1419)
%1421 = load i8**, i8*** %64
%1422 = load i64, i64* %27
%1423 = trunc i64 %1422 to i32
%1424 = call i32 @free_cmatrix(i8** %1421, i32 0, i32 %1423, i32 0, i32 120)
%1425 = load i8**, i8*** %65
%1426 = load i64, i64* %27
%1427 = trunc i64 %1426 to i32
%1428 = call i32 @free_cmatrix(i8** %1425, i32 0, i32 %1427, i32 0, i32 120)
%1429 = load i8**, i8*** %66
%1430 = load i64, i64* %27
%1431 = trunc i64 %1430 to i32
%1432 = call i32 @free_cmatrix(i8** %1429, i32 0, i32 %1431, i32 0, i32 120)
%1433 = load i8**, i8*** %67
%1434 = load i64, i64* %27
%1435 = trunc i64 %1434 to i32
%1436 = call i32 @free_cmatrix(i8** %1433, i32 0, i32 %1435, i32 0, i32 120)
%1437 = load i8**, i8*** %58
%1438 = call i32 @free_cmatrix(i8** %1437, i32 0, i32 512, i32 0, i32 4)
%1439 = load i8**, i8*** %59
%1440 = call i32 @free_cmatrix(i8** %1439, i32 0, i32 512, i32 0, i32 4)
%1441 = load double*, double** %92
%1442 = call i32 @free_dvector(double* %1441, i32 0, i32 512)
%1443 = load i64**, i64*** %85
%1444 = load i64, i64* %27
%1445 = call i32 @free_lmatrix(i64** %1443, i32 0, i64 %1444, i32 0, i64 101)
%1446 = load i64*, i64** %86
%1447 = load i64, i64* %27
%1448 = call i32 @free_lvector(i64* %1446, i32 0, i64 %1447)
%1449 = load i8*, i8** %95
store i8* %1449, i8** %25
br label %1450
1450: ; preds = %1399, %1311, %1229, %1143, %801, %547, %436, %331
%1451 = load i8*, i8** %25
ret i8* %1451
}

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