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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ baseinfo(char, long, char, char *, char, int, char *);
int /*<<< orphan*/ check_pair(long, long, char *, long **, double **, double **,
                              double **, double **, char **, double *, double *,
                              long *, int, char *);
int /*<<< orphan*/ free_lvector(long *, int, long);
long get_round(double);
int /*<<< orphan*/ lsort(long, long *, long *);
long *lvector(int, long);
int /*<<< orphan*/ multiplets(long, long, long, long **, long *, long *,
                              char **, char **, char *, long *, char **,
                              double **, double **, double **, long **, char *,
                              long *, long *, long **);
void bp_network(long num_residue, long *RY, long **seidx, char **AtomName,
                char **ResName, char *ChainID, long *ResSeq, char **Miscs,
                double **xyz, char *bseq, long **pair_info, double **Nxyz,
                double **orien, double **org, double *BPRS, long *num_multi,
                long *multi_idx, long **multi) {
  char b1[512], criteria[200];
  double rtn_val[21];
  long bpid, i, ir, j, k, m, inum_base, tnum_base = 0, max_ple = -1,
                                        num_ple = 0;
  long *ivec, *idx1, *idx2;
  for (i = 1; i <= num_residue; i++)
    if (RY[i] >= 0)
      tnum_base++;
  ivec = lvector(1, tnum_base);
  idx1 = lvector(1, tnum_base);
  idx2 = lvector(1, tnum_base);
  for (i = 1; i <= num_residue; i++) {
    if (RY[i] < 0)
      continue;
    ir = seidx[i][1];
    baseinfo(ChainID[ir], ResSeq[ir], Miscs[ir][2], ResName[ir], bseq[i], 1,
             b1);
    ivec[1] = i;
    for (j = 2; j <= tnum_base; j++)
      ivec[j] = 0;
    inum_base = 1;
    m = 1;
    while (ivec[m] && m <= tnum_base) {
      ir = ivec[m++];
      for (j = 1; j <= pair_info[ir][101L]; j++) {
        for (k = 1; k <= inum_base; k++)
          if (pair_info[ir][j] == ivec[k])
            break;
        if (k > inum_base)
          ivec[++inum_base] = pair_info[ir][j];
      }
    }
    for (j = 1; j <= inum_base - 1; j++) {
      if (ivec[j] < 0)
        continue;
      m = 0;
      for (k = j + 1; k <= inum_base; k++) {
        m++;
        if (ivec[k] < 0) {
          idx1[m] = 1000000 - ivec[k];
          continue;
        }
        check_pair(ivec[j], ivec[k], bseq, seidx, xyz, Nxyz, orien, org,
                   AtomName, BPRS, rtn_val, &bpid, 1, criteria);
        if (!bpid) {
          idx1[m] = 1000000 + ivec[k];
          ivec[k] = -ivec[k];
        } else
          idx1[m] = get_round(10000.0 * rtn_val[2]);
      }
      if (m > 1) {
        lsort(m, idx1, idx2);
        for (k = 1; k <= m; k++)
          idx1[k] = ivec[j + idx2[k]];
        for (k = 1; k <= m; k++)
          ivec[k + j] = idx1[k];
      }
    }
    k = 0;
    for (j = 2; j <= inum_base; j++)
      if (ivec[j] > 0) {
        if (++k >= 101L) {
          --k;
          break;
        } else
          pair_info[i][k] = ivec[j];
      }
    pair_info[i][101L] = k;
    if (k++ > 1) {
      num_ple++;
      if (k > max_ple)
        max_ple = k;
    }
  }
  if (num_ple)
    multiplets(num_ple, max_ple, num_residue, pair_info, ivec, idx1, AtomName,
               ResName, ChainID, ResSeq, Miscs, xyz, orien, org, seidx, bseq,
               num_multi, multi_idx, multi);
  free_lvector(ivec, 1, tnum_base);
  free_lvector(idx1, 1, tnum_base);
  free_lvector(idx2, 1, tnum_base);
}


x86 assembly (clang, -O0):
<bp_network>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4c8,%rsp
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,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8,-0x50(%rbp)
mov    %r9,-0x58(%rbp)
movq   $0x0,-0x420(%rbp)
movq   $0xffffffffffffffff,-0x428(%rbp)
ff ff ff ff
movq   $0x0,-0x430(%rbp)
movq   $0x1,-0x3f0(%rbp)
mov    -0x3f0(%rbp),%rax
cmp    -0x30(%rbp),%rax
jg     124d <bp_network+0xdd>
mov    -0x38(%rbp),%rax
mov    -0x3f0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jl     1231 <bp_network+0xc1>
mov    -0x420(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x420(%rbp)
jmp    1236 <bp_network+0xc6>
mov    -0x3f0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3f0(%rbp)
jmp    11f8 <bp_network+0x88>
mov    -0x420(%rbp),%rsi
mov    $0x1,%edi
call   1080 <lvector@plt>
mov    %rax,-0x438(%rbp)
mov    -0x420(%rbp),%rsi
mov    $0x1,%edi
call   1080 <lvector@plt>
mov    %rax,-0x440(%rbp)
mov    -0x420(%rbp),%rsi
mov    $0x1,%edi
call   1080 <lvector@plt>
mov    %rax,-0x448(%rbp)
movq   $0x1,-0x3f0(%rbp)
mov    -0x3f0(%rbp),%rax
cmp    -0x30(%rbp),%rax
jg     19b5 <bp_network+0x845>
mov    -0x38(%rbp),%rax
mov    -0x3f0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jge    12cc <bp_network+0x15c>
jmp    199e <bp_network+0x82e>
mov    -0x40(%rbp),%rax
mov    -0x3f0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x3f8(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,1),%dil
mov    0x10(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x18(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2(%rax),%dl
mov    -0x50(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x28(%rbp),%rax
mov    -0x3f0(%rbp),%r8
mov    (%rax,%r8,1),%r8b
lea    -0x260(%rbp),%rax
mov    $0x1,%r9d
movsbl %dil,%edi
movsbl %dl,%edx
movsbl %r8b,%r8d
mov    %rax,(%rsp)
call   1040 <baseinfo@plt>
mov    -0x3f0(%rbp),%rcx
mov    -0x438(%rbp),%rax
mov    %rcx,0x8(%rax)
movq   $0x2,-0x400(%rbp)
mov    -0x400(%rbp),%rax
cmp    -0x420(%rbp),%rax
jg     13b3 <bp_network+0x243>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x400(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x400(%rbp)
jmp    1372 <bp_network+0x202>
movq   $0x1,-0x418(%rbp)
movq   $0x1,-0x410(%rbp)
mov    -0x438(%rbp),%rcx
mov    -0x410(%rbp),%rdx
xor    %eax,%eax
cmpq   $0x0,(%rcx,%rdx,8)
mov    %al,-0x449(%rbp)
je     1401 <bp_network+0x291>
mov    -0x410(%rbp),%rax
cmp    -0x420(%rbp),%rax
setle  %al
mov    %al,-0x449(%rbp)
mov    -0x449(%rbp),%al
test   $0x1,%al
jne    1414 <bp_network+0x2a4>
jmp    154b <bp_network+0x3db>
mov    -0x438(%rbp),%rax
mov    -0x410(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x410(%rbp)
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x3f8(%rbp)
movq   $0x1,-0x400(%rbp)
mov    -0x400(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    -0x3f8(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x328(%rcx),%rax
jg     1546 <bp_network+0x3d6>
movq   $0x1,-0x408(%rbp)
mov    -0x408(%rbp),%rax
cmp    -0x418(%rbp),%rax
jg     14db <bp_network+0x36b>
mov    0x30(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x400(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x438(%rbp),%rcx
mov    -0x408(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jne    14bf <bp_network+0x34f>
jmp    14db <bp_network+0x36b>
jmp    14c4 <bp_network+0x354>
mov    -0x408(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
jmp    1474 <bp_network+0x304>
mov    -0x408(%rbp),%rax
cmp    -0x418(%rbp),%rax
jle    152a <bp_network+0x3ba>
mov    0x30(%rbp),%rax
mov    -0x3f8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x400(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x438(%rbp),%rax
mov    -0x418(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x418(%rbp)
mov    %rdx,0x8(%rax,%rcx,8)
jmp    152f <bp_network+0x3bf>
mov    -0x400(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x400(%rbp)
jmp    1446 <bp_network+0x2d6>
jmp    13c9 <bp_network+0x259>
movq   $0x1,-0x400(%rbp)
mov    -0x400(%rbp),%rax
mov    -0x418(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     1861 <bp_network+0x6f1>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jge    158f <bp_network+0x41f>
jmp    184a <bp_network+0x6da>
movq   $0x0,-0x410(%rbp)
mov    -0x400(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
mov    -0x408(%rbp),%rax
cmp    -0x418(%rbp),%rax
jg     174b <bp_network+0x5db>
mov    -0x410(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x410(%rbp)
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jge    1619 <bp_network+0x4a9>
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    $0xf4240,%edx
sub    (%rax,%rcx,8),%rdx
mov    -0x440(%rbp),%rax
mov    -0x410(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1734 <bp_network+0x5c4>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x28(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    0x38(%rbp),%r9
mov    0x40(%rbp),%r12
mov    0x48(%rbp),%r15
mov    -0x48(%rbp),%r14
mov    0x50(%rbp),%rbx
lea    -0x3e0(%rbp),%r11
lea    -0x330(%rbp),%rax
lea    -0x3e8(%rbp),%r10
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
movl   $0x1,0x30(%rsp)
mov    %rax,0x38(%rsp)
call   1030 <check_pair@plt>
cmpq   $0x0,-0x3e8(%rbp)
jne    1705 <bp_network+0x595>
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    $0xf4240,%rdx
mov    -0x440(%rbp),%rax
mov    -0x410(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
xor    %edx,%edx
sub    (%rax,%rcx,8),%rdx
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    172f <bp_network+0x5bf>
movsd  0x8f3(%rip),%xmm0
mulsd  -0x3d0(%rbp),%xmm0
ff
call   1060 <get_round@plt>
mov    %rax,%rdx
mov    -0x440(%rbp),%rax
mov    -0x410(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1734 <bp_network+0x5c4>
mov    -0x408(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
jmp    15ac <bp_network+0x43c>
cmpq   $0x1,-0x410(%rbp)
01
jle    1845 <bp_network+0x6d5>
mov    -0x410(%rbp),%rdi
mov    -0x440(%rbp),%rsi
mov    -0x448(%rbp),%rdx
call   1070 <lsort@plt>
movq   $0x1,-0x408(%rbp)
mov    -0x408(%rbp),%rax
cmp    -0x410(%rbp),%rax
jg     17df <bp_network+0x66f>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
mov    -0x448(%rbp),%rdx
mov    -0x408(%rbp),%rsi
add    (%rdx,%rsi,8),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x440(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x408(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
jmp    177e <bp_network+0x60e>
movq   $0x1,-0x408(%rbp)
mov    -0x408(%rbp),%rax
cmp    -0x410(%rbp),%rax
jg     1840 <bp_network+0x6d0>
mov    -0x440(%rbp),%rax
mov    -0x408(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x438(%rbp),%rax
mov    -0x408(%rbp),%rcx
add    -0x400(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x408(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
jmp    17ea <bp_network+0x67a>
jmp    1845 <bp_network+0x6d5>
jmp    184a <bp_network+0x6da>
mov    -0x400(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x400(%rbp)
jmp    1556 <bp_network+0x3e6>
movq   $0x0,-0x408(%rbp)
movq   $0x2,-0x400(%rbp)
mov    -0x400(%rbp),%rax
cmp    -0x418(%rbp),%rax
jg     1924 <bp_network+0x7b4>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jle    1908 <bp_network+0x798>
mov    -0x408(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x408(%rbp)
cmp    $0x65,%rax
jl     18d7 <bp_network+0x767>
mov    -0x408(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x408(%rbp)
jmp    1924 <bp_network+0x7b4>
mov    -0x438(%rbp),%rax
mov    -0x400(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    0x30(%rbp),%rax
mov    -0x3f0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x408(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1908 <bp_network+0x798>
jmp    190d <bp_network+0x79d>
mov    -0x400(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x400(%rbp)
jmp    1877 <bp_network+0x707>
mov    -0x408(%rbp),%rcx
mov    0x30(%rbp),%rax
mov    -0x3f0(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,0x328(%rax)
mov    -0x408(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x408(%rbp)
cmp    $0x1,%rax
jle    1999 <bp_network+0x829>
mov    -0x430(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x430(%rbp)
mov    -0x408(%rbp),%rax
cmp    -0x428(%rbp),%rax
jle    1994 <bp_network+0x824>
mov    -0x408(%rbp),%rax
mov    %rax,-0x428(%rbp)
jmp    1999 <bp_network+0x829>
jmp    199e <bp_network+0x82e>
mov    -0x3f0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x3f0(%rbp)
jmp    12a0 <bp_network+0x130>
cmpq   $0x0,-0x430(%rbp)
je     1ab4 <bp_network+0x944>
mov    -0x430(%rbp),%rdi
mov    -0x428(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    0x30(%rbp),%rcx
mov    -0x438(%rbp),%r8
mov    -0x440(%rbp),%r9
mov    -0x48(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x478(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x470(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x468(%rbp)
mov    0x18(%rbp),%rax
mov    %rax,-0x460(%rbp)
mov    0x20(%rbp),%r13
mov    0x40(%rbp),%r12
mov    0x48(%rbp),%r15
mov    -0x40(%rbp),%r14
mov    0x28(%rbp),%rbx
mov    0x58(%rbp),%r11
mov    0x60(%rbp),%r10
mov    0x68(%rbp),%rax
mov    %rax,-0x458(%rbp)
mov    -0x480(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x478(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x470(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x468(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x460(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x458(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1090 <multiplets@plt>
mov    -0x438(%rbp),%rdi
mov    -0x420(%rbp),%rdx
mov    $0x1,%esi
call   1050 <free_lvector@plt>
mov    -0x440(%rbp),%rdi
mov    -0x420(%rbp),%rdx
mov    $0x1,%esi
call   1050 <free_lvector@plt>
mov    -0x448(%rbp),%rdi
mov    -0x420(%rbp),%rdx
mov    $0x1,%esi
call   1050 <free_lvector@plt>
add    $0x4c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<bp_network>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x458,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0x80(%rsp)
mov    %rcx,0x90(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rsi,%r13
mov    %rdi,%r12
test   %rdi,%rdi
jle    11c8 <bp_network+0x48>
cmp    $0x4,%r12
jae    11cf <bp_network+0x4f>
mov    $0x1,%eax
xor    %ebx,%ebx
jmp    12be <bp_network+0x13e>
xor    %ebx,%ebx
jmp    12e8 <bp_network+0x168>
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1b24 <bp_network+0x9a4>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
or     $0x2,%rsi
and    %rcx,%rsi
pxor   %xmm3,%xmm3
mov    $0x1,%edx
pcmpeqd %xmm2,%xmm2
pxor   %xmm4,%xmm4
movdqu 0x0(%r13,%rdx,8),%xmm5
movdqu 0x10(%r13,%rdx,8),%xmm6
movdqu 0x20(%r13,%rdx,8),%xmm0
movdqu 0x30(%r13,%rdx,8),%xmm1
pxor   %xmm2,%xmm5
pxor   %xmm2,%xmm6
psrlq  $0x3f,%xmm5
paddq  %xmm3,%xmm5
psrlq  $0x3f,%xmm6
paddq  %xmm4,%xmm6
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
psrlq  $0x3f,%xmm0
paddq  %xmm5,%xmm0
psrlq  $0x3f,%xmm1
paddq  %xmm6,%xmm1
add    $0x8,%rdx
movdqa %xmm0,%xmm3
movdqa %xmm1,%xmm4
add    $0xfffffffffffffffe,%rsi
jne    1210 <bp_network+0x90>
test   $0x1,%cl
je     12a3 <bp_network+0x123>
movdqu 0x0(%r13,%rdx,8),%xmm2
movdqu 0x10(%r13,%rdx,8),%xmm3
pcmpeqd %xmm4,%xmm4
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm3
psrlq  $0x3f,%xmm2
paddq  %xmm2,%xmm0
psrlq  $0x3f,%xmm3
paddq  %xmm3,%xmm1
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rbx
cmp    %r12,%rax
je     12e8 <bp_network+0x168>
or     $0x1,%rax
lea    0x1(%r12),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rax,8),%rdx
not    %rdx
shr    $0x3f,%rdx
add    %rdx,%rbx
add    $0x1,%rax
cmp    %rax,%rcx
jne    12d0 <bp_network+0x150>
mov    $0x1,%edi
mov    %rbx,%rsi
call   1090 <lvector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %rbx,%rsi
call   1090 <lvector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %rbx,%rsi
call   1090 <lvector@plt>
mov    %rax,0x20(%rsp)
test   %r12,%r12
jle    1ae0 <bp_network+0x960>
lea    0x10(%r15),%rax
mov    %rax,0xa0(%rsp)
lea    -0x8(,%rbx,8),%rax
ff
mov    %rax,0x98(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0xa8(%rsp)
lea    0x18(%r14),%rax
mov    %rax,0xb0(%rsp)
movq   $0xffffffffffffffff,0x18(%rsp)
ff ff
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    %r14,%r8
mov    $0x1,%ebp
mov    %r12,0x70(%rsp)
mov    %r13,0x68(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r14,0x28(%rsp)
jmp    13c0 <bp_network+0x240>
lea    0x1(%rax),%rdx
mov    0x10(%rsp),%rbx
mov    0x18(%rsp),%rcx
addq   $0x1,0x60(%rsp)
cmp    %rcx,%rax
cmovge %rdx,%rcx
mov    %rcx,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rbp),%rax
cmp    %r12,%rbp
mov    %rax,%rbp
je     1a58 <bp_network+0x8d8>
cmpq   $0x0,0x0(%r13,%rbp,8)
js     13b0 <bp_network+0x230>
mov    0x50(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    0x8(%rax),%rax
mov    0x78(%rsp),%rcx
movsbl (%rcx,%rax,1),%edi
mov    0x490(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
mov    0x498(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movsbl 0x2(%rcx),%edx
mov    0x80(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    0x4a8(%rsp),%rax
movsbl (%rax,%rbp,1),%r8d
sub    $0x8,%rsp
mov    $0x1,%r9d
lea    0x258(%rsp),%rax
push   %rax
call   1040 <baseinfo@plt>
add    $0x10,%rsp
mov    %rbp,0x8(%rsp)
mov    %rbp,0x8(%r15)
cmp    $0x2,%rbx
jb     1455 <bp_network+0x2d5>
mov    0xa0(%rsp),%rdi
xor    %esi,%esi
mov    0x98(%rsp),%rdx
call   1070 <memset@plt>
test   %rbx,%rbx
mov    0x28(%rsp),%r8
je     19b0 <bp_network+0x830>
mov    $0x1,%r14d
mov    0x8(%rsp),%rdx
mov    $0x1,%eax
mov    0x4b0(%rsp),%r9
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%rcx
mov    (%r9,%rdx,8),%rdx
mov    0x328(%rdx),%rsi
test   %rsi,%rsi
jle    14f0 <bp_network+0x370>
mov    $0x1,%edi
jmp    14bc <bp_network+0x33c>
nopl   0x0(%rax,%rax,1)
mov    %rbp,0x8(%r15,%r14,8)
add    $0x1,%r14
mov    0x328(%rdx),%rsi
lea    0x1(%rdi),%rbp
cmp    %rsi,%rdi
mov    %rbp,%rdi
jge    14f0 <bp_network+0x370>
mov    (%rdx,%rdi,8),%rbp
test   %r14,%r14
jle    14a0 <bp_network+0x320>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
cmp    0x8(%r15,%rbx,8),%rbp
je     14b0 <bp_network+0x330>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    14d0 <bp_network+0x350>
jmp    14a0 <bp_network+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rcx,8),%rdx
test   %rdx,%rdx
je     1507 <bp_network+0x387>
cmp    0x10(%rsp),%rax
mov    %rcx,%rax
jb     1480 <bp_network+0x300>
cmp    $0x2,%r14
mov    0x70(%rsp),%r12
mov    0x68(%rsp),%r13
jl     19b0 <bp_network+0x830>
mov    $0x1,%r9d
mov    $0x3,%eax
mov    %rax,0x88(%rsp)
mov    %r15,%r10
xor    %eax,%eax
mov    %rax,0x58(%rsp)
jmp    1560 <bp_network+0x3e0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
addq   $0x1,0x58(%rsp)
add    $0x8,%r10
addq   $0x1,0x88(%rsp)
cmp    %r14,%r9
je     1994 <bp_network+0x814>
cmpq   $0x0,(%r15,%r9,8)
js     1540 <bp_network+0x3c0>
mov    0x58(%rsp),%rax
lea    (%r15,%rax,8),%rax
add    $0x10,%rax
mov    %rax,0xc0(%rsp)
mov    $0xffffffffffffffff,%r13
mov    $0xfffffffffffffff0,%rbx
mov    $0xfffffffffffffff8,%r12
mov    $0x1,%eax
mov    $0x2,%cl
mov    $0x2,%edx
mov    %r10,0x30(%rsp)
jmp    15ea <bp_network+0x46a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0xf4240,%eax
sub    %rsi,%rax
mov    %rax,0x10(%r8,%r13,8)
mov    0x58(%rsp),%rax
lea    (%rax,%r13,1),%rsi
add    $0x3,%rsi
add    $0x1,%r13
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%r12
lea    0x1(%r11),%rax
lea    0x1(%rdi),%ecx
lea    0x1(%rbp),%rdx
cmp    %r14,%rsi
jge    16f0 <bp_network+0x570>
mov    %rax,%r11
mov    %ecx,%edi
mov    %rdx,%rbp
mov    0x18(%r10,%r13,8),%rsi
test   %rsi,%rsi
js     15b0 <bp_network+0x430>
mov    %r11,0x38(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rbp,0x48(%rsp)
mov    %r9,%rbp
mov    (%r15,%r9,8),%rdi
mov    0x4a8(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0x4a0(%rsp),%r8
mov    0x4b8(%rsp),%r9
lea    0x180(%rsp),%rax
push   %rax
push   $0x1
lea    0xd8(%rsp),%rax
push   %rax
lea    0xe8(%rsp),%rax
push   %rax
push   0x4f0(%rsp)
push   0xb8(%rsp)
push   0x4f8(%rsp)
push   0x4f8(%rsp)
call   1030 <check_pair@plt>
add    $0x40,%rsp
cmpq   $0x0,0xc8(%rsp)
je     16b0 <bp_network+0x530>
movsd  0xe0(%rsp),%xmm0
mulsd  0x973(%rip),%xmm0
call   1060 <get_round@plt>
mov    0x28(%rsp),%r8
mov    %rax,0x10(%r8,%r13,8)
mov    %rbp,%r9
mov    0x30(%rsp),%r10
jmp    16d4 <bp_network+0x554>
cs nopw 0x0(%rax,%rax,1)
mov    0x30(%rsp),%r10
mov    0x18(%r10,%r13,8),%rax
mov    $0xf4240,%ecx
add    %rcx,%rax
mov    0x28(%rsp),%r8
mov    %rax,0x10(%r8,%r13,8)
negq   0x18(%r10,%r13,8)
mov    %rbp,%r9
mov    0x48(%rsp),%rbp
mov    0x40(%rsp),%rdi
mov    0x38(%rsp),%r11
jmp    15bd <bp_network+0x43d>
nopl   0x0(%rax,%rax,1)
test   %r13,%r13
je     1540 <bp_network+0x3c0>
mov    %rbx,0xb8(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rbp,0x48(%rsp)
lea    0x1(%r13),%rbx
mov    %rbx,%rdi
mov    %r8,%rsi
mov    0x20(%rsp),%rdx
mov    %r9,0x38(%rsp)
mov    %r11,%rbp
call   1080 <lsort@plt>
mov    0x38(%rsp),%r9
mov    0x28(%rsp),%r8
mov    $0x1,%eax
cmp    $0x3,%r13
jb     17a1 <bp_network+0x621>
mov    %rbp,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
mov    0x20(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsi,%rax,8),%rdx
add    %r9,%rdx
mov    (%r15,%rdx,8),%rdx
mov    %rdx,0x8(%r8,%rax,8)
mov    0x10(%rsi,%rax,8),%rdx
add    %r9,%rdx
mov    (%r15,%rdx,8),%rdx
mov    %rdx,0x10(%r8,%rax,8)
mov    0x18(%rsi,%rax,8),%rdx
add    %r9,%rdx
mov    (%r15,%rdx,8),%rdx
mov    %rdx,0x18(%r8,%rax,8)
mov    0x20(%rsi,%rax,8),%rdx
add    %r9,%rdx
mov    (%r15,%rdx,8),%rdx
mov    %rdx,0x20(%r8,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1750 <bp_network+0x5d0>
add    $0x1,%rax
test   $0x3,%bl
je     17d8 <bp_network+0x658>
lea    (%r8,%rax,8),%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %ebp,%edx
and    $0x3,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rsi,8),%rdi
add    %r9,%rdi
mov    (%r15,%rdi,8),%rdi
mov    %rdi,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    17c0 <bp_network+0x640>
mov    $0x1,%eax
cmp    $0x3,%r13
mov    0x48(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0xb8(%rsp),%rdx
jae    17ff <bp_network+0x67f>
mov    0x30(%rsp),%r10
jmp    18f0 <bp_network+0x770>
mov    %r8,%rcx
sub    %r12,%rcx
cmp    %rcx,0xc0(%rsp)
mov    0x30(%rsp),%r10
jae    1828 <bp_network+0x6a8>
mov    %r10,%rcx
sub    %rdx,%rcx
cmp    %rcx,0xa8(%rsp)
jb     18f0 <bp_network+0x770>
mov    %rbx,%rax
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1984 <bp_network+0x804>
and    $0xfffffffffffffffc,%rbp
add    $0xfffffffffffffffc,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups 0x8(%r8,%rdx,8),%xmm0
movups 0x18(%r8,%rdx,8),%xmm1
movups %xmm0,0x10(%r10,%rdx,8)
movups %xmm1,0x20(%r10,%rdx,8)
movdqu 0x28(%r8,%rdx,8),%xmm0
movdqu 0x38(%r8,%rdx,8),%xmm1
movdqu %xmm0,0x30(%r10,%rdx,8)
movdqu %xmm1,0x40(%r10,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbp
jne    1870 <bp_network+0x6f0>
test   $0x1,%cl
je     18d4 <bp_network+0x754>
or     $0x1,%rdx
movdqu (%r8,%rdx,8),%xmm0
movdqu 0x10(%r8,%rdx,8),%xmm1
add    %r9,%rdx
movdqu %xmm0,(%r15,%rdx,8)
movdqu %xmm1,0x10(%r15,%rdx,8)
cmp    %rax,%rbx
je     1540 <bp_network+0x3c0>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
sub    %rax,%r13
lea    0x2(%r13),%ecx
add    $0x1,%r13
test   $0x3,%cl
je     1923 <bp_network+0x7a3>
sub    %al,%sil
movzbl %sil,%ecx
and    $0x3,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r8,%rax,8),%rdx
mov    %rdx,0x8(%r10,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1910 <bp_network+0x790>
cmp    $0x3,%r13
jb     1540 <bp_network+0x3c0>
sub    %rax,%rdi
mov    0x88(%rsp),%rcx
add    %rax,%rcx
lea    (%r15,%rcx,8),%rcx
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
mov    -0x18(%rax,%rdx,8),%rsi
mov    %rsi,-0x10(%rcx,%rdx,8)
mov    -0x10(%rax,%rdx,8),%rsi
mov    %rsi,-0x8(%rcx,%rdx,8)
mov    -0x8(%rax,%rdx,8),%rsi
mov    %rsi,(%rcx,%rdx,8)
mov    (%rax,%rdx,8),%rsi
mov    %rsi,0x8(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    1950 <bp_network+0x7d0>
jmp    1540 <bp_network+0x3c0>
xor    %edx,%edx
test   $0x1,%cl
jne    18b3 <bp_network+0x733>
jmp    18d4 <bp_network+0x754>
cmp    $0x2,%r14
mov    0x70(%rsp),%r12
mov    0x68(%rsp),%r13
jge    19d6 <bp_network+0x856>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4b0(%rsp),%rax
mov    0x8(%rsp),%rbp
mov    (%rax,%rbp,8),%rax
movq   $0x0,0x328(%rax)
mov    0x10(%rsp),%rbx
jmp    13b0 <bp_network+0x230>
add    $0xffffffffffffffff,%r14
xor    %ecx,%ecx
xor    %eax,%eax
jmp    19f1 <bp_network+0x871>
mov    %rsi,0x8(%rdi,%rax,8)
mov    %rdx,%rax
add    $0x1,%rcx
cmp    %rcx,%r14
je     1a31 <bp_network+0x8b1>
mov    0x10(%r15,%rcx,8),%rsi
test   %rsi,%rsi
jle    19e8 <bp_network+0x868>
lea    0x1(%rax),%rdx
mov    0x4b0(%rsp),%rdi
mov    0x8(%rsp),%rbp
mov    (%rdi,%rbp,8),%rdi
cmp    $0x64,%rax
jl     19e0 <bp_network+0x860>
mov    %rax,0x328(%rdi)
mov    0x10(%rsp),%rbx
mov    0x18(%rsp),%rcx
mov    0x8(%rsp),%rbp
jmp    1393 <bp_network+0x213>
mov    0x4b0(%rsp),%rcx
mov    0x8(%rsp),%rbp
mov    (%rcx,%rbp,8),%rcx
mov    %rax,0x328(%rcx)
cmp    $0x2,%rax
jl     19cc <bp_network+0x84c>
jmp    1385 <bp_network+0x205>
mov    0x60(%rsp),%rdi
test   %rdi,%rdi
mov    %r8,%r14
je     1ae0 <bp_network+0x960>
sub    $0x8,%rsp
mov    0x20(%rsp),%rsi
mov    %r12,%rdx
mov    0x4b8(%rsp),%rcx
mov    %r15,%r8
mov    %r14,%r9
push   0x4f0(%rsp)
push   0x4f0(%rsp)
push   0x4f0(%rsp)
push   0x4c8(%rsp)
push   0x78(%rsp)
push   0x4f8(%rsp)
push   0x4f8(%rsp)
push   0x4e0(%rsp)
push   0x4e0(%rsp)
push   0x4e0(%rsp)
push   0xd0(%rsp)
push   0xe0(%rsp)
push   0xf8(%rsp)
call   10a0 <multiplets@plt>
add    $0x70,%rsp
mov    %r15,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1050 <free_lvector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1050 <free_lvector@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
call   1050 <free_lvector@plt>
add    $0x458,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
mov    $0x1,%edx
pxor   %xmm1,%xmm1
test   $0x1,%cl
jne    1277 <bp_network+0xf7>
jmp    12a3 <bp_network+0x123>

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

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