#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 */
double distance_ab(double **, long, long, int, int);
int /*<<< orphan*/ dswap(double *, double *);
int /*<<< orphan*/ free_lvector(long *, int, long);
int /*<<< orphan*/ get_d1_d2(long, long, long *, double **, double *, double *);
int /*<<< orphan*/ get_ij(long, long *, long **, long *, long *);
int /*<<< orphan*/ lreverse(long, long, long *);
int /*<<< orphan*/ lswap(long *, long *);
long *lvector(int, long);
void five2three(long num_bp, long *num_helix, long **helix_idx, long *bp_idx,
                double **bp_xyz, long **base_pairs, double **o3_p) {
  double di1_i2, di2_i1, di1_j2, dj1_i2, dj1_j2, dj2_j1;
  double d1, d2, O3P = 5.0;
  long i, i1, i2, j, j1, j2, k, m, n, nswap, nwc;
  long direction[9], *swapped;
  for (i = 1; i <= *num_helix; i++)
    for (j = helix_idx[i][1]; j <= helix_idx[i][2]; j++) {
      i1 = base_pairs[bp_idx[j]][1];
      di1_i2 = distance_ab(o3_p, i1, i1, 4, 8);
      if (di1_i2 > 0.0 && di1_i2 <= 2.5) {
        return;
      }
    }
  swapped = lvector(1, num_bp);
  for (i = 1; i <= *num_helix; i++) {
    helix_idx[i][3] = helix_idx[i][2] - helix_idx[i][1] + 1;
    nwc = 0;
    for (j = helix_idx[i][1]; j < helix_idx[i][2]; j++) {
      m = bp_idx[j];
      n = bp_idx[j + 1];
      if (base_pairs[m][3] > 0 && base_pairs[n][3] > 0) {
        nwc++;
        get_d1_d2(m, n, swapped, bp_xyz, &d1, &d2);
        if (d1 < 0.0) {
          swapped[n] = !swapped[n];
          if (d2 < 0.0)
            swapped[m] = !swapped[m];
        } else {
          if (d2 < 0.0) {
            swapped[n] = !swapped[n];
            if (nwc == 1)
              swapped[m] = !swapped[m];
          }
        }
        get_d1_d2(m, n, swapped, bp_xyz, &d1, &d2);
        if (d1 < 0.0)
          swapped[n] = !swapped[n];
      } else {
        nwc = 0;
        get_ij(m, swapped, base_pairs, &i1, &j1);
        get_ij(n, swapped, base_pairs, &i2, &j2);
        di1_i2 = distance_ab(o3_p, i1, i2, 4, 4);
        di1_j2 = distance_ab(o3_p, i1, j2, 4, 4);
        dj1_i2 = distance_ab(o3_p, j1, i2, 4, 4);
        dj1_j2 = distance_ab(o3_p, j1, j2, 4, 4);
        if ((di1_i2 > 0.0 && di1_j2 > 0.0 && di1_i2 > di1_j2) &&
            (dj1_i2 > 0.0 && dj1_j2 > 0.0 && dj1_j2 > dj1_i2))
          swapped[n] = !swapped[n];
      }
    }
    for (j = 1; j <= 8; j++)
      direction[j] = 0;
    for (j = helix_idx[i][1]; j < helix_idx[i][2]; j++) {
      m = bp_idx[j];
      get_ij(m, swapped, base_pairs, &i1, &j1);
      n = bp_idx[j + 1];
      get_ij(n, swapped, base_pairs, &i2, &j2);
      di1_i2 = distance_ab(o3_p, i1, i2, 4, 8);
      dj2_j1 = distance_ab(o3_p, j2, j1, 4, 8);
      if (di1_i2 > O3P)
        ++direction[1];
      else if (di1_i2 > 0.0)
        ++direction[2];
      if (dj2_j1 > O3P)
        ++direction[3];
      else if (dj2_j1 > 0.0)
        ++direction[4];
      di2_i1 = distance_ab(o3_p, i2, i1, 4, 8);
      dj1_j2 = distance_ab(o3_p, j1, j2, 4, 8);
      if (di2_i1 > O3P)
        ++direction[5];
      else if (di2_i1 > 0.0)
        ++direction[6];
      if (dj1_j2 > O3P)
        ++direction[7];
      else if (dj1_j2 > 0.0)
        ++direction[8];
    }
    if ((direction[1] - direction[2]) * (direction[5] - direction[6]) > 0 ||
        (direction[3] - direction[4]) * (direction[7] - direction[8]) > 0)
      helix_idx[i][7] = 1;
    else {
      if ((direction[1] && direction[2]) || (direction[3] && direction[4]) ||
          (direction[5] && direction[6]) || (direction[7] && direction[8]))
        helix_idx[i][5] = 1;
      if (direction[1] > direction[2] || direction[5] < direction[6]) {
        if (direction[3] > direction[4] || direction[7] < direction[8]) {
          m = bp_idx[helix_idx[i][1]];
          get_ij(m, swapped, base_pairs, &i1, &j1);
          n = bp_idx[helix_idx[i][2]];
          get_ij(n, swapped, base_pairs, &i2, &j2);
          if (i2 < j1)
            lreverse(helix_idx[i][1], helix_idx[i][3], bp_idx);
          else {
            for (j = helix_idx[i][1]; j <= helix_idx[i][2]; j++)
              swapped[bp_idx[j]] = !swapped[bp_idx[j]];
          }
        } else {
          helix_idx[i][6] = 1;
          lreverse(helix_idx[i][1], helix_idx[i][3], bp_idx);
        }
      } else {
        if (direction[3] > direction[4] || direction[7] < direction[8])
          helix_idx[i][6] = 1;
      }
    }
    nswap = 0;
    for (j = helix_idx[i][1]; j <= helix_idx[i][2]; j++)
      if (swapped[bp_idx[j]])
        nswap++;
    if (nswap)
      for (j = helix_idx[i][1]; j <= helix_idx[i][2]; j++) {
        m = bp_idx[j];
        if (swapped[m]) {
          lswap(&base_pairs[m][1], &base_pairs[m][2]);
          for (k = 1; k <= 3; k++) {
            dswap(&bp_xyz[m][k + 3], &bp_xyz[m][k + 6]);
            lswap(&base_pairs[m][k + 11], &base_pairs[m][k + 14]);
          }
        }
      }
  }
  free_lvector(swapped, 1, num_bp);
}


x86 assembly (clang, -O0):
<five2three>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  0xe51(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movq   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%rax
jg     12a6 <five2three+0x126>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1290 <five2three+0x110>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x98(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x88(%rbp)
mov    0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1274 <five2three+0xf4>
movsd  0xda4(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jb     1274 <five2three+0xf4>
jmp    1f47 <five2three+0xdc7>
jmp    1279 <five2three+0xf9>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    11e4 <five2three+0x64>
jmp    1295 <five2three+0x115>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    11bc <five2three+0x3c>
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   10a0 <lvector@plt>
mov    %rax,-0x128(%rbp)
movq   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%rax
jg     1f32 <five2three+0xdb2>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
sub    0x8(%rax),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,0x18(%rax)
movq   $0x0,-0xd0(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jge    16fe <five2three+0x57e>
mov    -0x20(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpq   $0x0,0x18(%rax)
jle    155a <five2three+0x3da>
mov    -0x30(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpq   $0x0,0x18(%rax)
jle    155a <five2three+0x3da>
mov    -0xd0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    -0x128(%rbp),%rdx
mov    -0x28(%rbp),%rcx
lea    -0x68(%rbp),%r8
lea    -0x70(%rbp),%r9
call   1080 <get_d1_d2@plt>
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1465 <five2three+0x2e5>
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1460 <five2three+0x2e0>
mov    -0x128(%rbp),%rax
mov    -0xb8(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ef <five2three+0x36f>
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    14ea <five2three+0x36a>
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
cmpq   $0x1,-0xd0(%rbp)
01
jne    14e5 <five2three+0x365>
mov    -0x128(%rbp),%rax
mov    -0xb8(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ea <five2three+0x36a>
jmp    14ef <five2three+0x36f>
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    -0x128(%rbp),%rdx
mov    -0x28(%rbp),%rcx
lea    -0x68(%rbp),%r8
lea    -0x70(%rbp),%r9
call   1080 <get_d1_d2@plt>
xorps  %xmm0,%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1555 <five2three+0x3d5>
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    16e2 <five2three+0x562>
movq   $0x0,-0xd0(%rbp)
mov    -0xb8(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x88(%rbp),%rcx
lea    -0xa0(%rbp),%r8
call   1090 <get_ij@plt>
mov    -0xc0(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x90(%rbp),%rcx
lea    -0xa8(%rbp),%r8
call   1090 <get_ij@plt>
mov    0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    $0x4,%r8d
mov    %r8d,%ecx
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x38(%rbp)
mov    0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    $0x4,%r8d
mov    %r8d,%ecx
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x48(%rbp)
mov    0x10(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    $0x4,%r8d
mov    %r8d,%ecx
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x50(%rbp)
mov    0x10(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    $0x4,%r8d
mov    %r8d,%ecx
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16dd <five2three+0x55d>
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16dd <five2three+0x55d>
movsd  -0x38(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    16dd <five2three+0x55d>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16dd <five2three+0x55d>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16dd <five2three+0x55d>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    16dd <five2three+0x55d>
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    16e2 <five2three+0x562>
jmp    16e7 <five2three+0x567>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    132a <five2three+0x1aa>
movq   $0x1,-0x98(%rbp)
cmpq   $0x8,-0x98(%rbp)
08
jg     1741 <five2three+0x5c1>
mov    -0x98(%rbp),%rax
movq   $0x0,-0x120(%rbp,%rax,8)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1709 <five2three+0x589>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jge    19e4 <five2three+0x864>
mov    -0x20(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x88(%rbp),%rcx
lea    -0xa0(%rbp),%r8
call   1090 <get_ij@plt>
mov    -0x20(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x90(%rbp),%rcx
lea    -0xa8(%rbp),%r8
call   1090 <get_ij@plt>
mov    0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x38(%rbp)
mov    0x10(%rbp),%rdi
mov    -0xa8(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1861 <five2three+0x6e1>
mov    -0x118(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x118(%rbp)
jmp    188a <five2three+0x70a>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1885 <five2three+0x705>
mov    -0x110(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x110(%rbp)
jmp    188a <five2three+0x70a>
movsd  -0x60(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    18b1 <five2three+0x731>
mov    -0x108(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x108(%rbp)
jmp    18da <five2three+0x75a>
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    18d5 <five2three+0x755>
mov    -0x100(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x100(%rbp)
jmp    18da <five2three+0x75a>
mov    0x10(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x40(%rbp)
mov    0x10(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    194f <five2three+0x7cf>
mov    -0xf8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xf8(%rbp)
jmp    1978 <five2three+0x7f8>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1973 <five2three+0x7f3>
mov    -0xf0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xf0(%rbp)
jmp    1978 <five2three+0x7f8>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    199f <five2three+0x81f>
mov    -0xe8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe8(%rbp)
jmp    19c8 <five2three+0x848>
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19c3 <five2three+0x843>
mov    -0xe0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe0(%rbp)
jmp    19c8 <five2three+0x848>
jmp    19cd <five2three+0x84d>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1758 <five2three+0x5d8>
mov    -0x118(%rbp),%rax
sub    -0x110(%rbp),%rax
mov    -0xf8(%rbp),%rcx
sub    -0xf0(%rbp),%rcx
imul   %rcx,%rax
cmp    $0x0,%rax
jg     1a38 <five2three+0x8b8>
mov    -0x108(%rbp),%rax
sub    -0x100(%rbp),%rax
mov    -0xe8(%rbp),%rcx
sub    -0xe0(%rbp),%rcx
imul   %rcx,%rax
cmp    $0x0,%rax
jle    1a51 <five2three+0x8d1>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movq   $0x1,0x38(%rax)
jmp    1d0e <five2three+0xb8e>
cmpq   $0x0,-0x118(%rbp)
je     1a6d <five2three+0x8ed>
cmpq   $0x0,-0x110(%rbp)
jne    1ac1 <five2three+0x941>
cmpq   $0x0,-0x108(%rbp)
je     1a89 <five2three+0x909>
cmpq   $0x0,-0x100(%rbp)
jne    1ac1 <five2three+0x941>
cmpq   $0x0,-0xf8(%rbp)
je     1aa5 <five2three+0x925>
cmpq   $0x0,-0xf0(%rbp)
jne    1ac1 <five2three+0x941>
cmpq   $0x0,-0xe8(%rbp)
je     1ad5 <five2three+0x955>
cmpq   $0x0,-0xe0(%rbp)
je     1ad5 <five2three+0x955>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movq   $0x1,0x28(%rax)
mov    -0x118(%rbp),%rax
cmp    -0x110(%rbp),%rax
jg     1afd <five2three+0x97d>
mov    -0xf8(%rbp),%rax
cmp    -0xf0(%rbp),%rax
jge    1cc8 <five2three+0xb48>
mov    -0x108(%rbp),%rax
cmp    -0x100(%rbp),%rax
jg     1b25 <five2three+0x9a5>
mov    -0xe8(%rbp),%rax
cmp    -0xe0(%rbp),%rax
jge    1c86 <five2three+0xb06>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    0x8(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x88(%rbp),%rcx
lea    -0xa0(%rbp),%r8
call   1090 <get_ij@plt>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    0x10(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x30(%rbp),%rdx
lea    -0x90(%rbp),%rcx
lea    -0xa8(%rbp),%r8
call   1090 <get_ij@plt>
mov    -0x90(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    1bef <five2three+0xa6f>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rdi
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rax),%rsi
mov    -0x20(%rbp),%rdx
call   1030 <lreverse@plt>
jmp    1c81 <five2three+0xb01>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1c7c <five2three+0xafc>
mov    -0x128(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x98(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
movslq %eax,%rdx
mov    -0x128(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x98(%rbp),%rsi
mov    (%rcx,%rsi,8),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1c06 <five2three+0xa86>
jmp    1c81 <five2three+0xb01>
jmp    1cc3 <five2three+0xb43>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movq   $0x1,0x30(%rax)
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rdi
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rax),%rsi
mov    -0x20(%rbp),%rdx
call   1030 <lreverse@plt>
jmp    1d09 <five2three+0xb89>
mov    -0x108(%rbp),%rax
cmp    -0x100(%rbp),%rax
jg     1cf0 <five2three+0xb70>
mov    -0xe8(%rbp),%rax
cmp    -0xe0(%rbp),%rax
jge    1d04 <five2three+0xb84>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movq   $0x1,0x30(%rax)
jmp    1d09 <five2three+0xb89>
jmp    1d0e <five2three+0xb8e>
movq   $0x0,-0xc8(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1d9c <five2three+0xc1c>
mov    -0x128(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x98(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1d80 <five2three+0xc00>
mov    -0xc8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc8(%rbp)
jmp    1d85 <five2three+0xc05>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1d30 <five2three+0xbb0>
cmpq   $0x0,-0xc8(%rbp)
je     1f1c <five2three+0xd9c>
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x10(%rcx),%rax
jg     1f17 <five2three+0xd97>
mov    -0x20(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x128(%rbp),%rax
mov    -0xb8(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1efb <five2three+0xd7b>
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
add    $0x8,%rdi
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
add    $0x10,%rsi
call   1070 <lswap@plt>
movq   $0x1,-0xb0(%rbp)
cmpq   $0x3,-0xb0(%rbp)
03
jg     1ef6 <five2three+0xd76>
mov    -0x28(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0xb0(%rbp),%rax
add    $0x3,%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0xb0(%rbp),%rax
add    $0x6,%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1050 <dswap@plt>
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0xb0(%rbp),%rax
add    $0xb,%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0xb0(%rbp),%rax
add    $0xe,%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1070 <lswap@plt>
mov    -0xb0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xb0(%rbp)
jmp    1e43 <five2three+0xcc3>
jmp    1efb <five2three+0xd7b>
jmp    1f00 <five2three+0xd80>
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1dc1 <five2three+0xc41>
jmp    1f1c <five2three+0xd9c>
jmp    1f21 <five2three+0xda1>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    12c3 <five2three+0x143>
mov    -0x128(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_lvector@plt>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<five2three>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%rbp
mov    %r8,0x88(%rsp)
mov    %rcx,(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rdi,%r15
mov    %rsi,0x70(%rsp)
mov    (%rsi),%rax
test   %rax,%rax
mov    %r9,0x68(%rsp)
jle    1274 <five2three+0xf4>
mov    $0x1,%r14d
jmp    11f2 <five2three+0x72>
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,0x28(%rsp)
mov    0x70(%rsp),%rax
mov    (%rax),%rax
mov    0x68(%rsp),%rbp
lea    0x1(%r14),%rcx
cmp    %rax,%r14
mov    %rcx,%r14
jge    1274 <five2three+0xf4>
mov    0x8(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
mov    0x8(%rcx),%rbx
cmp    0x10(%rcx),%rbx
jg     11e2 <five2three+0x62>
add    $0xffffffffffffffff,%rbx
jmp    1223 <five2three+0xa3>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
mov    (%rax,%r14,8),%rax
add    $0x1,%rbx
cmp    0x10(%rax),%rbx
jge    11d0 <five2three+0x50>
mov    (%rsp),%rax
mov    0x8(%rax,%rbx,8),%rax
mov    0x68(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    0x8(%rax),%rbp
mov    0xe0(%rsp),%rdi
mov    %rbp,%rsi
mov    %rbp,%rdx
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
ucomisd 0xdb1(%rip),%xmm0
jbe    1210 <five2three+0x90>
movsd  0xd97(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     1210 <five2three+0x90>
jmp    1ab4 <five2three+0x934>
mov    $0x1,%edi
mov    %r15,0xa0(%rsp)
mov    %r15,%rsi
call   10a0 <lvector@plt>
mov    %rax,%r12
mov    0x70(%rsp),%rax
cmpq   $0x0,(%rax)
mov    (%rsp),%rbx
jle    1a9f <five2three+0x91f>
mov    $0x1,%r13d
jmp    12ca <five2three+0x14a>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r13),%rax
mov    0x70(%rsp),%rcx
cmp    (%rcx),%r13
mov    %rax,%r13
mov    0x68(%rsp),%rbp
jge    1a9f <five2three+0x91f>
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x8(%rax),%r14
mov    0x10(%rax),%rcx
mov    %rcx,%rdx
sub    %r14,%rdx
add    $0x1,%rdx
mov    %rdx,0x18(%rax)
cmp    %r14,%rcx
mov    %r13,0x30(%rsp)
jle    1578 <five2three+0x3f8>
xor    %ebx,%ebx
jmp    1327 <five2three+0x1a7>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cmpq   $0x0,(%r12,%r15,8)
sete   %cl
mov    %rcx,(%r12,%r15,8)
mov    %rax,%rbx
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x10(%rax),%rcx
cmp    %rcx,%r14
jge    1570 <five2three+0x3f0>
mov    (%rsp),%rax
mov    (%rax,%r14,8),%r13
mov    0x8(%rax,%r14,8),%r15
add    $0x1,%r14
mov    0x0(%rbp,%r13,8),%rax
cmpq   $0x0,0x18(%rax)
jle    13b0 <five2three+0x230>
mov    0x0(%rbp,%r15,8),%rax
cmpq   $0x0,0x18(%rax)
jle    13b0 <five2three+0x230>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    0x88(%rsp),%rcx
lea    0x98(%rsp),%r8
lea    0x90(%rsp),%r9
call   1080 <get_d1_d2@plt>
xorpd  %xmm0,%xmm0
ucomisd 0x98(%rsp),%xmm0
jbe    14d9 <five2three+0x359>
xor    %eax,%eax
cmpq   $0x0,(%r12,%r15,8)
sete   %al
mov    %rax,(%r12,%r15,8)
ucomisd 0x90(%rsp),%xmm0
ja     14f7 <five2three+0x377>
jmp    1505 <five2three+0x385>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x28(%rsp),%rcx
lea    0x18(%rsp),%r8
call   1090 <get_ij@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x20(%rsp),%rcx
lea    0x38(%rsp),%r8
call   1090 <get_ij@plt>
mov    0x28(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    0xe0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x4,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,0x60(%rsp)
mov    0x28(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x4,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,0x58(%rsp)
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x4,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x18(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x4,%r8d
call   1060 <distance_ab@plt>
movsd  0x60(%rsp),%xmm2
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jbe    154f <five2three+0x3cf>
movsd  0x58(%rsp),%xmm3
ucomisd %xmm1,%xmm3
mov    $0x0,%ebx
mov    0x30(%rsp),%r13
jbe    1311 <five2three+0x191>
ucomisd %xmm3,%xmm2
jbe    155b <five2three+0x3db>
movsd  0x10(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    155b <five2three+0x3db>
ucomisd %xmm1,%xmm0
jbe    155b <five2three+0x3db>
ucomisd %xmm2,%xmm0
mov    $0x0,%eax
mov    $0x0,%ebx
ja     1300 <five2three+0x180>
jmp    1311 <five2three+0x191>
ucomisd 0x90(%rsp),%xmm0
jbe    1505 <five2three+0x385>
xor    %eax,%eax
cmpq   $0x0,(%r12,%r15,8)
sete   %al
mov    %rax,(%r12,%r15,8)
test   %rbx,%rbx
jne    1505 <five2three+0x385>
xor    %eax,%eax
cmpq   $0x0,(%r12,%r13,8)
sete   %al
mov    %rax,(%r12,%r13,8)
add    $0x1,%rbx
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    0x88(%rsp),%rcx
lea    0x98(%rsp),%r8
lea    0x90(%rsp),%r9
call   1080 <get_d1_d2@plt>
xorpd  %xmm0,%xmm0
ucomisd 0x98(%rsp),%xmm0
mov    %rbx,%rax
mov    0x30(%rsp),%r13
ja     1300 <five2three+0x180>
jmp    1311 <five2three+0x191>
xor    %ebx,%ebx
mov    0x30(%rsp),%r13
jmp    1311 <five2three+0x191>
xor    %ebx,%ebx
jmp    1311 <five2three+0x191>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rax),%r14
mov    (%rsp),%rbx
cmp    %rcx,%r14
jge    1760 <five2three+0x5e0>
xor    %eax,%eax
mov    %rax,0x50(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %eax,%eax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,0x48(%rsp)
xor    %r15d,%r15d
xor    %eax,%eax
mov    %rax,0x78(%rsp)
jmp    15d9 <five2three+0x459>
nopw   0x0(%rax,%rax,1)
addq   $0x1,0x50(%rsp)
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%rax
cmp    0x10(%rax),%r14
jge    1797 <five2three+0x617>
mov    (%rbx,%r14,8),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x28(%rsp),%rcx
lea    0x18(%rsp),%r8
call   1090 <get_ij@plt>
mov    0x8(%rbx,%r14,8),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x20(%rsp),%rcx
lea    0x38(%rsp),%r8
call   1090 <get_ij@plt>
mov    0x28(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    0xe0(%rsp),%r13
mov    %r13,%rdi
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,0x60(%rsp)
mov    0x38(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13,%rdi
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  0x60(%rsp),%xmm2
ucomisd 0x9a6(%rip),%xmm2
jbe    1690 <five2three+0x510>
add    $0x1,%r15
mov    0x30(%rsp),%r13
xorpd  %xmm1,%xmm1
ucomisd 0x98f(%rip),%xmm0
ja     16af <five2three+0x52f>
ucomisd %xmm1,%xmm0
jbe    16b5 <five2three+0x535>
addq   $0x1,0x48(%rsp)
jmp    16b5 <five2three+0x535>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jbe    16a0 <five2three+0x520>
addq   $0x1,0x78(%rsp)
mov    0x30(%rsp),%r13
ucomisd 0x95b(%rip),%xmm0
jbe    167b <five2three+0x4fb>
addq   $0x1,0x10(%rsp)
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    0xe0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  %xmm0,0x60(%rsp)
mov    0x18(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x4,%ecx
mov    $0x8,%r8d
call   1060 <distance_ab@plt>
movsd  0x60(%rsp),%xmm2
ucomisd 0x8fd(%rip),%xmm2
jbe    1720 <five2three+0x5a0>
addq   $0x1,0x58(%rsp)
xorpd  %xmm1,%xmm1
jmp    1733 <five2three+0x5b3>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jbe    1733 <five2three+0x5b3>
addq   $0x1,0x80(%rsp)
mov    (%rsp),%rbx
add    $0x1,%r14
ucomisd 0x8c5(%rip),%xmm0
ja     15c0 <five2three+0x440>
ucomisd %xmm1,%xmm0
jbe    15c6 <five2three+0x446>
addq   $0x1,0x40(%rsp)
jmp    15c6 <five2three+0x446>
xchg   %ax,%ax
xor    %ecx,%ecx
mov    %rcx,0x78(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x48(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x58(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x80(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x50(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x40(%rsp)
xor    %r15d,%r15d
mov    %r15,%rcx
mov    0x78(%rsp),%r8
sub    %r8,%rcx
mov    0x58(%rsp),%rsi
mov    %rsi,%rdx
mov    0x80(%rsp),%rdi
sub    %rdi,%rdx
imul   %rcx,%rdx
test   %rdx,%rdx
jg     17df <five2three+0x65f>
mov    0x10(%rsp),%rcx
sub    0x48(%rsp),%rcx
mov    0x50(%rsp),%rdx
sub    0x40(%rsp),%rdx
imul   %rcx,%rdx
test   %rdx,%rdx
jle    1973 <five2three+0x7f3>
movq   $0x1,0x38(%rax)
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%r9
mov    0x8(%r9),%r14
mov    0x10(%r9),%r8
mov    %r8,%rsi
sub    %r14,%rsi
jl     12b0 <five2three+0x130>
lea    0x1(%rsi),%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x3,%rsi
jae    1820 <five2three+0x6a0>
xor    %esi,%esi
mov    %r14,%rbx
jmp    1871 <five2three+0x6f1>
nopw   0x0(%rax,%rax,1)
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
mov    %rbx,%rax
mov    %r14,%rbx
nopl   0x0(%rax)
mov    (%rax,%rbx,8),%rbp
mov    0x8(%rax,%rbx,8),%rcx
cmpq   $0x1,(%r12,%rbp,8)
sbb    $0xffffffffffffffff,%rsi
cmpq   $0x1,(%r12,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
mov    0x10(%rax,%rbx,8),%rcx
cmpq   $0x1,(%r12,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
mov    0x18(%rax,%rbx,8),%rcx
cmpq   $0x1,(%r12,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
add    $0x4,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1830 <five2three+0x6b0>
test   %rdx,%rdx
je     1896 <five2three+0x716>
mov    (%rsp),%rax
lea    (%rax,%rbx,8),%rdi
xor    %ebp,%ebp
mov    (%rdi,%rbp,8),%rcx
cmpq   $0x1,(%r12,%rcx,8)
sbb    $0xffffffffffffffff,%rsi
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1880 <five2three+0x700>
test   %rsi,%rsi
mov    (%rsp),%rbx
je     12b0 <five2three+0x130>
cmp    %r14,%r8
jl     12b0 <five2three+0x130>
add    $0xffffffffffffffff,%r14
jmp    18ce <five2three+0x74e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x10(%r9),%r14
jge    12b0 <five2three+0x130>
mov    0x8(%rbx,%r14,8),%rbp
cmpq   $0x0,(%r12,%rbp,8)
je     18c0 <five2three+0x740>
mov    0x68(%rsp),%r15
mov    (%r15,%rbp,8),%rsi
lea    0x8(%rsi),%rdi
add    $0x10,%rsi
call   1070 <lswap@plt>
mov    0x88(%rsp),%rbx
mov    (%rbx,%rbp,8),%rsi
lea    0x20(%rsi),%rdi
add    $0x38,%rsi
call   1050 <dswap@plt>
mov    (%r15,%rbp,8),%rsi
lea    0x60(%rsi),%rdi
add    $0x78,%rsi
call   1070 <lswap@plt>
mov    (%rbx,%rbp,8),%rsi
lea    0x28(%rsi),%rdi
add    $0x40,%rsi
call   1050 <dswap@plt>
mov    (%r15,%rbp,8),%rsi
lea    0x68(%rsi),%rdi
sub    $0xffffffffffffff80,%rsi
call   1070 <lswap@plt>
mov    (%rbx,%rbp,8),%rsi
mov    (%rsp),%rbx
lea    0x30(%rsi),%rdi
add    $0x48,%rsi
call   1050 <dswap@plt>
mov    (%r15,%rbp,8),%rsi
lea    0x70(%rsi),%rdi
add    $0x88,%rsi
call   1070 <lswap@plt>
mov    0x8(%rsp),%rax
mov    (%rax,%r13,8),%r9
jmp    18c0 <five2three+0x740>
test   %r15,%r15
je     197d <five2three+0x7fd>
test   %r8,%r8
jne    19a7 <five2three+0x827>
cmpq   $0x0,0x10(%rsp)
je     198d <five2three+0x80d>
cmpq   $0x0,0x48(%rsp)
jne    19a7 <five2three+0x827>
test   %rsi,%rsi
je     1997 <five2three+0x817>
test   %rdi,%rdi
jne    19a7 <five2three+0x827>
cmpq   $0x0,0x50(%rsp)
je     19af <five2three+0x82f>
cmpq   $0x0,0x40(%rsp)
je     19af <five2three+0x82f>
movq   $0x1,0x28(%rax)
mov    0x48(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
setg   %dl
mov    0x40(%rsp),%rcx
cmp    %rcx,0x50(%rsp)
setl   %cl
or     %dl,%cl
cmp    %r8,%r15
jg     19ea <five2three+0x86a>
cmp    %rdi,%rsi
jl     19ea <five2three+0x86a>
test   %cl,%cl
je     17e7 <five2three+0x667>
movq   $0x1,0x30(%rax)
jmp    17e7 <five2three+0x667>
test   %cl,%cl
je     1a82 <five2three+0x902>
mov    0x8(%rax),%rax
mov    (%rbx,%rax,8),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x28(%rsp),%rcx
lea    0x18(%rsp),%r8
call   1090 <get_ij@plt>
mov    0x8(%rsp),%r14
mov    (%r14,%r13,8),%rax
mov    0x10(%rax),%rax
mov    (%rbx,%rax,8),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
lea    0x20(%rsp),%rcx
lea    0x38(%rsp),%r8
call   1090 <get_ij@plt>
mov    0x20(%rsp),%rcx
mov    (%r14,%r13,8),%rax
mov    0x8(%rax),%rdi
cmp    0x18(%rsp),%rcx
jl     1a8e <five2three+0x90e>
cmp    0x10(%rax),%rdi
jg     17e7 <five2three+0x667>
add    $0xffffffffffffffff,%rdi
nopw   0x0(%rax,%rax,1)
mov    0x8(%rbx,%rdi,8),%rcx
xor    %edx,%edx
cmpq   $0x0,(%r12,%rcx,8)
sete   %dl
mov    %rdx,(%r12,%rcx,8)
add    $0x1,%rdi
cmp    0x10(%rax),%rdi
jl     1a60 <five2three+0x8e0>
jmp    17e7 <five2three+0x667>
movq   $0x1,0x30(%rax)
mov    0x8(%rax),%rdi
mov    0x18(%rax),%rsi
mov    %rbx,%rdx
call   1030 <lreverse@plt>
jmp    17e7 <five2three+0x667>
mov    %r12,%rdi
mov    $0x1,%esi
mov    0xa0(%rsp),%rdx
call   1040 <free_lvector@plt>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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