#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 fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
void neiK(double **x, int dim, int comp1, int comp2, int i, int bs,
          double epsgrid, int K, int **box, int *lis, int *nn) {
  double *dn, *xx;
  int k, ix, iy, ix1, iy1, ix2, jj, step, ib = bs - 1;
  int el;
  double dd, dy;
  int d;
  dn = (double *)malloc((K + 1) * sizeof(double));
  xx = (double *)malloc(dim * sizeof(double));
  for (k = 0; k < dim; k++)
    xx[k] = x[k][i];
  dn[0] = 0;
  for (k = 1; k <= K; k++)
    dn[k] = 1e30;
  ix = (int)(xx[comp1] / epsgrid) & ib;
  iy = (int)(xx[comp2] / epsgrid) & ib;
  jj = 0;
  while (dn[K] > epsgrid * (jj - 1)) {
    step = (jj) ? 2 * jj : 1;
    for (ix1 = ix - jj; ix1 <= ix + jj; ix1++) {
      ix2 = ix1 & ib;
      for (iy1 = iy - jj; iy1 <= iy + jj; iy1 += step) {
        el = box[ix2][iy1 & ib];
        while (el != -1) {
          if (el != i) {
            dd = fabs(xx[0] - x[0][el]);
            for (d = 1; d < dim; d++)
              if ((dy = fabs(xx[d] - x[d][el])) > dd)
                dd = dy;
            if (dd < dn[K]) {
              k = K;
              while (dd < dn[k]) {
                if (k < K) {
                  dn[k + 1] = dn[k];
                  nn[k + 1] = nn[k];
                }
                k--;
              }
              dn[k + 1] = dd;
              nn[k + 1] = el;
            }
          }
          el = lis[el];
        }
      }
    }
    for (ix1 = ix - jj; ix1 <= ix + jj; ix1 += step) {
      ix2 = ix1 & ib;
      for (iy1 = iy - jj + 1; iy1 <= iy + jj - 1; iy1++) {
        el = box[ix2][iy1 & ib];
        while (el != -1) {
          if (el != i) {
            dd = fabs(xx[0] - x[0][el]);
            for (d = 1; d < dim; d++)
              if ((dy = fabs(xx[d] - x[d][el])) > dd)
                dd = dy;
            if ((dy = fabs(xx[1] - x[1][el])) > dd)
              dd = dy;
            if (dd < dn[K]) {
              k = K;
              while (dd < dn[k]) {
                if (k < K) {
                  dn[k + 1] = dn[k];
                  nn[k + 1] = nn[k];
                }
                k--;
              }
              dn[k + 1] = dd;
              nn[k + 1] = el;
            }
          }
          el = lis[el];
        }
      }
    }
    jj++;
    if (jj == bs / 2)
      break;
  }
  if (jj == (bs / 2)) {
    for (ix1 = ix - jj; ix1 < ix + jj; ix1++) {
      ix2 = ix1 & ib;
      iy1 = iy - jj;
      el = box[ix2][iy1 & ib];
      while (el != -1) {
        if (el != i) {
          dd = fabs(xx[0] - x[0][el]);
          for (d = 1; d < dim; d++)
            if ((dy = fabs(xx[d] - x[d][el])) > dd)
              dd = dy;
          if (dd < dn[K]) {
            k = K;
            while (dd < dn[k]) {
              if (k < K) {
                dn[k + 1] = dn[k];
                nn[k + 1] = nn[k];
              }
              k--;
            }
            dn[k + 1] = dd;
            nn[k + 1] = el;
          }
        }
        el = lis[el];
      }
    }
    ix1 = ix - jj;
    ix2 = ix1 & ib;
    for (iy1 = iy - jj + 1; iy1 <= iy + jj - 1; iy1++) {
      el = box[ix2][iy1 & ib];
      while (el != -1) {
        if (el != i) {
          dd = fabs(xx[0] - x[0][el]);
          for (d = 1; d < dim; d++)
            if ((dy = fabs(xx[d] - x[d][el])) > dd)
              dd = dy;
          if (dd < dn[K]) {
            k = K;
            while (dd < dn[k]) {
              if (k < K) {
                dn[k + 1] = dn[k];
                nn[k + 1] = nn[k];
              }
              k--;
            }
            dn[k + 1] = dd;
            nn[k + 1] = el;
          }
        }
        el = lis[el];
      }
    }
  }
  free(dn);
  free(xx);
}


x86 assembly (clang, -O0):
<neiK>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ca <neiK+0xaa>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    118e <neiK+0x6e>
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     120b <neiK+0xeb>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xe18(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11dc <neiK+0xbc>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm1
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    170f <neiK+0x5ef>
cmpl   $0x0,-0x54(%rbp)
je     128c <neiK+0x16c>
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1299 <neiK+0x179>
mov    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1299 <neiK+0x179>
mov    -0x78(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jg     149c <neiK+0x37c>
mov    -0x48(%rbp),%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jg     1489 <neiK+0x369>
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
and    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0xffffffff,-0x60(%rbp)
je     1476 <neiK+0x356>
mov    -0x60(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1463 <neiK+0x343>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xcd4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13a2 <neiK+0x282>
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xc8f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    138f <neiK+0x26f>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1394 <neiK+0x274>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    133c <neiK+0x21c>
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    145e <neiK+0x33e>
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1434 <neiK+0x314>
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1426 <neiK+0x306>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    13c4 <neiK+0x2a4>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1463 <neiK+0x343>
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    12f7 <neiK+0x1d7>
jmp    147b <neiK+0x35b>
mov    -0x58(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    12cb <neiK+0x1ab>
jmp    148e <neiK+0x36e>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12a8 <neiK+0x188>
mov    -0x40(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jg     16de <neiK+0x5be>
mov    -0x48(%rbp),%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     16cb <neiK+0x5ab>
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
and    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0xffffffff,-0x60(%rbp)
je     16b8 <neiK+0x598>
mov    -0x60(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     16a5 <neiK+0x585>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xad1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a5 <neiK+0x485>
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa8c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    1592 <neiK+0x472>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1597 <neiK+0x477>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    153f <neiK+0x41f>
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa3a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    15e4 <neiK+0x4c4>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16a0 <neiK+0x580>
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1676 <neiK+0x556>
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1668 <neiK+0x548>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1606 <neiK+0x4e6>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    16a5 <neiK+0x585>
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    14fa <neiK+0x3da>
jmp    16bd <neiK+0x59d>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14cb <neiK+0x3ab>
jmp    16d0 <neiK+0x5b0>
mov    -0x58(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    14a5 <neiK+0x385>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
cmp    %ecx,%eax
jne    170a <neiK+0x5ea>
jmp    170f <neiK+0x5ef>
jmp    124a <neiK+0x12a>
mov    -0x54(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
cmp    %ecx,%eax
jne    1aea <neiK+0x9ca>
mov    -0x40(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    -0x54(%rbp),%ecx
cmp    %ecx,%eax
jge    1906 <neiK+0x7e6>
mov    -0x48(%rbp),%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
and    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0xffffffff,-0x60(%rbp)
je     18f3 <neiK+0x7d3>
mov    -0x60(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     18e0 <neiK+0x7c0>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x857(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    181f <neiK+0x6ff>
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x812(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    180c <neiK+0x6ec>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1811 <neiK+0x6f1>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    17b9 <neiK+0x699>
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18db <neiK+0x7bb>
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18b1 <neiK+0x791>
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18a3 <neiK+0x783>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1841 <neiK+0x721>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    18e0 <neiK+0x7c0>
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    1774 <neiK+0x654>
jmp    18f8 <neiK+0x7d8>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1736 <neiK+0x616>
mov    -0x40(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
and    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1ae5 <neiK+0x9c5>
mov    0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
and    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0xffffffff,-0x60(%rbp)
je     1ad2 <neiK+0x9b2>
mov    -0x60(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1abf <neiK+0x99f>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x678(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19fe <neiK+0x8de>
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x633(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    19eb <neiK+0x8cb>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    19f0 <neiK+0x8d0>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1998 <neiK+0x878>
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1aba <neiK+0x99a>
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x68(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a90 <neiK+0x970>
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a82 <neiK+0x962>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a20 <neiK+0x900>
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%edx
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1abf <neiK+0x99f>
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    1953 <neiK+0x833>
jmp    1ad7 <neiK+0x9b7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1924 <neiK+0x804>
jmp    1aea <neiK+0x9ca>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<neiK>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movsd  %xmm0,0x80(%rsp)
mov    %r9,0x28(%rsp)
mov    %r8d,%r15d
mov    %ecx,0x20(%rsp)
mov    %edx,0x18(%rsp)
mov    %esi,%ebp
mov    %rbp,0x40(%rsp)
mov    %rdi,%rbx
mov    0xd8(%rsp),%r13
mov    0xd0(%rsp),%r14
mov    0xc8(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0xc0(%rsp),%eax
mov    %rax,0x8(%rsp)
lea    0x8(,%rax,8),%edi
call   1040 <malloc@plt>
mov    %rax,%r12
lea    0x0(,%rbp,8),%edi
call   1040 <malloc@plt>
mov    %rax,%rbp
mov    0x40(%rsp),%rax
mov    %eax,%r10d
test   %eax,%eax
jle    1247 <neiK+0x127>
movslq %r15d,%rax
lea    -0x1(%r10),%rdx
mov    %r10d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rdx
jae    11c3 <neiK+0xa3>
xor    %edx,%edx
jmp    1218 <neiK+0xf8>
mov    %r10d,%esi
and    $0xfffffffc,%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
mov    0x8(%rbx,%rdx,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rdx,8)
mov    0x10(%rbx,%rdx,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rdx,8)
mov    0x18(%rbx,%rdx,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    11d0 <neiK+0xb0>
test   %r8,%r8
je     1247 <neiK+0x127>
lea    0x0(,%rdx,8),%rsi
add    %rbp,%rsi
lea    (%rbx,%rdx,8),%rdx
xor    %edi,%edi
xchg   %ax,%ax
mov    (%rdx,%rdi,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r8
jne    1230 <neiK+0x110>
mov    0x28(%rsp),%r8
lea    -0x1(%r8),%eax
mov    %eax,(%rsp)
movq   $0x0,(%r12)
mov    0x8(%rsp),%r9
test   %r9d,%r9d
movsd  0x80(%rsp),%xmm5
jle    135d <neiK+0x23d>
mov    %r9d,%eax
mov    $0x1,%ecx
cmp    $0x4,%r9d
jb     133a <neiK+0x21a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0xc,%rsi
jae    12a7 <neiK+0x187>
xor    %esi,%esi
jmp    12fa <neiK+0x1da>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
movaps 0xd4c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,0x8(%r12,%rsi,8)
movups %xmm0,0x18(%r12,%rsi,8)
movups %xmm0,0x28(%r12,%rsi,8)
movups %xmm0,0x38(%r12,%rsi,8)
movups %xmm0,0x48(%r12,%rsi,8)
movups %xmm0,0x58(%r12,%rsi,8)
movups %xmm0,0x68(%r12,%rsi,8)
movups %xmm0,0x78(%r12,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdi
jne    12c0 <neiK+0x1a0>
test   %rdx,%rdx
je     1331 <neiK+0x211>
movaps 0xcfa(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rsi,8),%rdi
or     $0x8,%rdi
movups %xmm0,(%r12,%rdi,1)
movups %xmm0,0x10(%r12,%rdi,1)
add    $0x4,%rsi
add    $0xffffffffffffffff,%rdx
jne    1310 <neiK+0x1f0>
cmp    %rcx,%rax
je     135d <neiK+0x23d>
or     $0x1,%rcx
add    $0x1,%rax
movabs $0x46293e5939a08cea,%rdx
3e 29 46
nopl   0x0(%rax,%rax,1)
mov    %rdx,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1350 <neiK+0x230>
movslq 0x18(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
divsd  %xmm5,%xmm0
cvttsd2si %xmm0,%esi
movslq 0x20(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
divsd  %xmm5,%xmm0
cvttsd2si %xmm0,%ecx
mov    (%rsp),%eax
and    %eax,%esi
and    %eax,%ecx
movslq %r9d,%r9
mov    %rcx,0x10(%rsp)
lea    -0x1(%rcx),%eax
mov    %r8d,%ecx
shr    $0x1f,%ecx
add    %r8d,%ecx
sar    %ecx
mov    %rcx,0x58(%rsp)
lea    -0x1(%r9),%r8
lea    -0x1(%r10),%rcx
add    $0xfffffffffffffffe,%r10
mov    %r10,0x28(%rsp)
mov    %rcx,%rdx
mov    %rcx,0x20(%rsp)
mov    %rcx,%r10
and    $0xfffffffffffffffe,%r10
neg    %r10
movapd 0xc40(%rip),%xmm0
movapd 0xc38(%rip),%xmm1
mov    %rax,0x78(%rsp)
mov    %eax,0x54(%rsp)
xor    %ecx,%ecx
mov    %rsi,0x30(%rsp)
mov    %esi,%eax
mov    %esi,0x4c(%rsp)
jmp    140c <neiK+0x2ec>
addl   $0x1,0x4c(%rsp)
mov    0x70(%rsp),%rcx
add    $0x1,%ecx
addl   $0x1,0x54(%rsp)
cmp    0x58(%rsp),%ecx
je     185c <neiK+0x73c>
lea    -0x1(%rcx),%eax
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movsd  (%r12,%r9,8),%xmm3
mulsd  %xmm5,%xmm2
ucomisd %xmm2,%xmm3
jbe    1852 <neiK+0x732>
lea    (%rcx,%rcx,1),%edx
test   %ecx,%ecx
mov    $0x1,%eax
cmove  %eax,%edx
mov    %edx,0x18(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%edx
sub    %ecx,%edx
mov    %rcx,0x70(%rsp)
add    %ecx,%eax
mov    %edx,0x4(%rsp)
mov    %eax,0x48(%rsp)
cmp    %eax,%edx
jg     13f0 <neiK+0x2d0>
mov    0x10(%rsp),%rax
mov    %eax,%edx
mov    0x70(%rsp),%rcx
sub    %ecx,%edx
mov    %edx,0x50(%rsp)
add    %ecx,%eax
mov    %eax,0x8(%rsp)
mov    0x4(%rsp),%eax
mov    %rax,0x38(%rsp)
jmp    1497 <neiK+0x377>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x4c(%rsp),%ecx
mov    %rax,0x38(%rsp)
je     1650 <neiK+0x530>
mov    0x8(%rsp),%eax
cmp    %eax,0x50(%rsp)
jg     1480 <neiK+0x360>
mov    0x38(%rsp),%rax
and    (%rsp),%eax
cltq
mov    0x60(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    %rax,0x68(%rsp)
mov    0x50(%rsp),%r11d
jmp    14cc <neiK+0x3ac>
add    0x18(%rsp),%r11d
cmp    0x8(%rsp),%r11d
jg     1480 <neiK+0x360>
mov    %r11d,%eax
and    (%rsp),%eax
cltq
mov    0x68(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
cmp    $0xffffffff,%eax
jne    14fc <neiK+0x3dc>
jmp    14c0 <neiK+0x3a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rcx
mov    (%r14,%rcx,4),%eax
cmp    $0xffffffff,%eax
je     14c0 <neiK+0x3a0>
cmp    %r15d,%eax
je     14f0 <neiK+0x3d0>
movsd  0x0(%rbp),%xmm2
mov    (%rbx),%rdx
movslq %eax,%rcx
subsd  (%rdx,%rcx,8),%xmm2
andpd  %xmm0,%xmm2
cmpl   $0x2,0x40(%rsp)
jl     15a7 <neiK+0x487>
cmpq   $0x0,0x28(%rsp)
je     1639 <neiK+0x519>
mov    $0x1,%edx
movapd %xmm2,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rdx,8),%xmm4
movsd  0x8(%rbp,%rdx,8),%xmm2
mov    (%rbx,%rdx,8),%rdi
mov    0x8(%rbx,%rdx,8),%rsi
subsd  (%rdi,%rcx,8),%xmm4
andpd  %xmm1,%xmm4
maxsd  %xmm3,%xmm4
subsd  (%rsi,%rcx,8),%xmm2
andpd  %xmm1,%xmm2
maxsd  %xmm4,%xmm2
lea    (%r10,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
movapd %xmm2,%xmm3
cmp    $0x1,%rsi
jne    1540 <neiK+0x420>
testb  $0x1,0x20(%rsp)
je     15a7 <neiK+0x487>
movsd  0x0(%rbp,%rdx,8),%xmm3
mov    (%rbx,%rdx,8),%rdx
subsd  (%rdx,%rcx,8),%xmm3
andpd  %xmm0,%xmm3
maxsd  %xmm2,%xmm3
movapd %xmm3,%xmm2
movsd  (%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
jbe    1627 <neiK+0x507>
movsd  -0x8(%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
mov    %r8,%rdx
jbe    1600 <neiK+0x4e0>
mov    %r8,%rdx
jmp    15e1 <neiK+0x4c1>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rdx,8),%xmm3
add    $0xffffffffffffffff,%rdx
ucomisd %xmm2,%xmm3
jbe    1600 <neiK+0x4e0>
cmp    %r9,%rdx
jge    15d0 <neiK+0x4b0>
movsd  %xmm3,0x8(%r12,%rdx,8)
mov    0x0(%r13,%rdx,4),%esi
mov    %esi,0x4(%r13,%rdx,4)
jmp    15d0 <neiK+0x4b0>
nopl   0x0(%rax)
shl    $0x20,%rdx
movabs $0x100000000,%rsi
add    %rsi,%rdx
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  %xmm2,(%r12,%rsi,1)
sar    $0x1e,%rdx
mov    %eax,0x0(%r13,%rdx,1)
mov    (%r14,%rcx,4),%eax
cmp    $0xffffffff,%eax
jne    14fc <neiK+0x3dc>
jmp    14c0 <neiK+0x3a0>
mov    $0x1,%edx
testb  $0x1,0x20(%rsp)
jne    158c <neiK+0x46c>
jmp    15a7 <neiK+0x487>
xchg   %ax,%ax
mov    0x48(%rsp),%eax
cmp    %eax,0x4(%rsp)
jg     13f0 <neiK+0x2d0>
mov    0x10(%rsp),%rax
mov    0x70(%rsp),%rcx
sub    %ecx,%eax
mov    %eax,0x68(%rsp)
mov    0x78(%rsp),%rax
add    %ecx,%eax
mov    %eax,0x38(%rsp)
jmp    1696 <neiK+0x576>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%eax
add    0x18(%rsp),%eax
mov    %eax,0x4(%rsp)
cmp    0x48(%rsp),%eax
jg     13f0 <neiK+0x2d0>
mov    0x38(%rsp),%eax
cmp    %eax,0x68(%rsp)
jge    1680 <neiK+0x560>
mov    0x4(%rsp),%eax
and    (%rsp),%eax
cltq
mov    0x60(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    %rax,0x8(%rsp)
mov    0x68(%rsp),%esi
jmp    16c6 <neiK+0x5a6>
nopl   (%rax)
cmp    0x54(%rsp),%esi
je     1680 <neiK+0x560>
add    $0x1,%esi
mov    %esi,%eax
and    (%rsp),%eax
cltq
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
jmp    16e7 <neiK+0x5c7>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rcx
mov    (%r14,%rcx,4),%eax
cmp    $0xffffffff,%eax
je     16c0 <neiK+0x5a0>
cmp    %r15d,%eax
je     16e0 <neiK+0x5c0>
movsd  0x0(%rbp),%xmm2
mov    (%rbx),%rdx
movslq %eax,%rcx
subsd  (%rdx,%rcx,8),%xmm2
andpd  %xmm0,%xmm2
cmpl   $0x2,0x40(%rsp)
jl     179a <neiK+0x67a>
cmpq   $0x0,0x28(%rsp)
je     183c <neiK+0x71c>
mov    $0x1,%r11d
movapd %xmm2,%xmm3
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r11,8),%xmm4
movsd  0x8(%rbp,%r11,8),%xmm2
mov    (%rbx,%r11,8),%rdx
mov    0x8(%rbx,%r11,8),%rdi
subsd  (%rdx,%rcx,8),%xmm4
andpd  %xmm1,%xmm4
maxsd  %xmm3,%xmm4
subsd  (%rdi,%rcx,8),%xmm2
andpd  %xmm1,%xmm2
maxsd  %xmm4,%xmm2
lea    (%r10,%r11,1),%rdx
add    $0x2,%rdx
add    $0x2,%r11
movapd %xmm2,%xmm3
cmp    $0x1,%rdx
jne    1730 <neiK+0x610>
testb  $0x1,0x20(%rsp)
je     179a <neiK+0x67a>
movsd  0x0(%rbp,%r11,8),%xmm3
mov    (%rbx,%r11,8),%rdx
subsd  (%rdx,%rcx,8),%xmm3
andpd  %xmm0,%xmm3
maxsd  %xmm2,%xmm3
movapd %xmm3,%xmm2
movsd  0x8(%rbp),%xmm3
mov    0x8(%rbx),%rdx
subsd  (%rdx,%rcx,8),%xmm3
andpd  %xmm0,%xmm3
maxsd  %xmm2,%xmm3
movsd  (%r12,%r9,8),%xmm2
ucomisd %xmm3,%xmm2
jbe    16e3 <neiK+0x5c3>
movsd  -0x8(%r12,%r9,8),%xmm2
ucomisd %xmm3,%xmm2
mov    %r8,%rdx
jbe    1810 <neiK+0x6f0>
mov    %r8,%rdx
jmp    17f1 <neiK+0x6d1>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r12,%rdx,8),%xmm2
add    $0xffffffffffffffff,%rdx
ucomisd %xmm3,%xmm2
jbe    1810 <neiK+0x6f0>
cmp    %r9,%rdx
jge    17e0 <neiK+0x6c0>
movsd  %xmm2,0x8(%r12,%rdx,8)
mov    0x0(%r13,%rdx,4),%edi
mov    %edi,0x4(%r13,%rdx,4)
jmp    17e0 <neiK+0x6c0>
nopl   0x0(%rax)
shl    $0x20,%rdx
movabs $0x100000000,%rdi
add    %rdi,%rdx
mov    %rdx,%rdi
sar    $0x1d,%rdi
movsd  %xmm3,(%r12,%rdi,1)
sar    $0x1e,%rdx
mov    %eax,0x0(%r13,%rdx,1)
jmp    16e3 <neiK+0x5c3>
mov    $0x1,%r11d
testb  $0x1,0x20(%rsp)
jne    177e <neiK+0x65e>
jmp    179a <neiK+0x67a>
cmp    0x58(%rsp),%ecx
jne    1bdb <neiK+0xabb>
mov    0x30(%rsp),%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%rcx,1),%esi
sub    %edx,%ecx
mov    0x10(%rsp),%rax
sub    %edx,%eax
mov    %rax,0x10(%rsp)
mov    %rcx,0x30(%rsp)
mov    %esi,0x8(%rsp)
cmp    %esi,%ecx
jge    1a30 <neiK+0x910>
mov    0x10(%rsp),%rax
and    (%rsp),%eax
cltq
mov    %rax,0x18(%rsp)
lea    -0x1(%r9),%r11
mov    0x30(%rsp),%rax
mov    %eax,%esi
jmp    18bd <neiK+0x79d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%esi
cmp    0x8(%rsp),%esi
je     1a30 <neiK+0x910>
mov    %esi,%eax
and    (%rsp),%eax
cltq
mov    0x60(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    0x18(%rsp),%rcx
mov    (%rax,%rcx,4),%eax
jmp    190b <neiK+0x7eb>
nopw   0x0(%rax,%rax,1)
shl    $0x20,%rdx
movabs $0x100000000,%rdi
add    %rdi,%rdx
mov    %rdx,%rdi
sar    $0x1d,%rdi
movsd  %xmm2,(%r12,%rdi,1)
sar    $0x1e,%rdx
mov    %eax,0x0(%r13,%rdx,1)
mov    (%r14,%rcx,4),%eax
cmp    $0xffffffff,%eax
je     18b0 <neiK+0x790>
movslq %eax,%rcx
cmp    %r15d,%eax
je     1907 <neiK+0x7e7>
movsd  0x0(%rbp),%xmm2
mov    (%rbx),%rdx
subsd  (%rdx,%rcx,8),%xmm2
andpd  %xmm0,%xmm2
cmpl   $0x2,0x40(%rsp)
jl     19ba <neiK+0x89a>
cmpq   $0x0,0x28(%rsp)
je     1a1d <neiK+0x8fd>
mov    $0x1,%r8d
movapd %xmm2,%xmm3
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r8,8),%xmm4
movsd  0x8(%rbp,%r8,8),%xmm2
mov    (%rbx,%r8,8),%rdx
mov    0x8(%rbx,%r8,8),%rdi
subsd  (%rdx,%rcx,8),%xmm4
andpd  %xmm1,%xmm4
maxsd  %xmm3,%xmm4
subsd  (%rdi,%rcx,8),%xmm2
andpd  %xmm1,%xmm2
maxsd  %xmm4,%xmm2
lea    (%r10,%r8,1),%rdx
add    $0x2,%rdx
add    $0x2,%r8
movapd %xmm2,%xmm3
cmp    $0x1,%rdx
jne    1950 <neiK+0x830>
testb  $0x1,0x20(%rsp)
je     19ba <neiK+0x89a>
movsd  0x0(%rbp,%r8,8),%xmm3
mov    (%rbx,%r8,8),%rdx
subsd  (%rdx,%rcx,8),%xmm3
andpd  %xmm0,%xmm3
maxsd  %xmm2,%xmm3
movapd %xmm3,%xmm2
movsd  (%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
jbe    1907 <neiK+0x7e7>
movsd  -0x8(%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
mov    %r11,%rdx
jbe    18e0 <neiK+0x7c0>
mov    %r11,%rdx
jmp    1a05 <neiK+0x8e5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%r12,%rdx,8),%xmm3
add    $0xffffffffffffffff,%rdx
ucomisd %xmm2,%xmm3
jbe    18e0 <neiK+0x7c0>
cmp    %r9,%rdx
jge    19f0 <neiK+0x8d0>
movsd  %xmm3,0x8(%r12,%rdx,8)
mov    0x0(%r13,%rdx,4),%edi
mov    %edi,0x4(%r13,%rdx,4)
jmp    19f0 <neiK+0x8d0>
mov    $0x1,%r8d
testb  $0x1,0x20(%rsp)
jne    199e <neiK+0x87e>
jmp    19ba <neiK+0x89a>
mov    0x78(%rsp),%rax
add    0x58(%rsp),%eax
cmp    %eax,0x10(%rsp)
jge    1bdb <neiK+0xabb>
mov    %rax,%r8
mov    0x30(%rsp),%rax
and    (%rsp),%eax
cltq
mov    0x60(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    %rax,0x8(%rsp)
lea    -0x1(%r9),%r11
jmp    1a7b <neiK+0x95b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r8d,0x10(%rsp)
je     1bdb <neiK+0xabb>
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x10(%rsp)
and    (%rsp),%eax
cltq
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
jmp    1acb <neiK+0x9ab>
nopw   0x0(%rax,%rax,1)
shl    $0x20,%rdx
movabs $0x100000000,%rsi
add    %rsi,%rdx
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  %xmm2,(%r12,%rsi,1)
sar    $0x1e,%rdx
mov    %eax,0x0(%r13,%rdx,1)
mov    (%r14,%rcx,4),%eax
cmp    $0xffffffff,%eax
je     1a70 <neiK+0x950>
movslq %eax,%rcx
cmp    %r15d,%eax
je     1ac7 <neiK+0x9a7>
movsd  0x0(%rbp),%xmm2
mov    (%rbx),%rdx
subsd  (%rdx,%rcx,8),%xmm2
andpd  %xmm0,%xmm2
cmpl   $0x2,0x40(%rsp)
jl     1b77 <neiK+0xa57>
cmpq   $0x0,0x28(%rsp)
je     1bcd <neiK+0xaad>
mov    $0x1,%edx
movapd %xmm2,%xmm3
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,8),%xmm4
movsd  0x8(%rbp,%rdx,8),%xmm2
mov    (%rbx,%rdx,8),%rsi
mov    0x8(%rbx,%rdx,8),%rdi
subsd  (%rsi,%rcx,8),%xmm4
andpd  %xmm1,%xmm4
maxsd  %xmm3,%xmm4
subsd  (%rdi,%rcx,8),%xmm2
andpd  %xmm1,%xmm2
maxsd  %xmm4,%xmm2
lea    (%r10,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
movapd %xmm2,%xmm3
cmp    $0x1,%rsi
jne    1b10 <neiK+0x9f0>
testb  $0x1,0x20(%rsp)
je     1b77 <neiK+0xa57>
movsd  0x0(%rbp,%rdx,8),%xmm3
mov    (%rbx,%rdx,8),%rdx
subsd  (%rdx,%rcx,8),%xmm3
andpd  %xmm0,%xmm3
maxsd  %xmm2,%xmm3
movapd %xmm3,%xmm2
movsd  (%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
jbe    1ac7 <neiK+0x9a7>
movsd  -0x8(%r12,%r9,8),%xmm3
ucomisd %xmm2,%xmm3
mov    %r11,%rdx
jbe    1aa0 <neiK+0x980>
mov    %r11,%rdx
jmp    1bb5 <neiK+0xa95>
movsd  -0x8(%r12,%rdx,8),%xmm3
add    $0xffffffffffffffff,%rdx
ucomisd %xmm2,%xmm3
jbe    1aa0 <neiK+0x980>
cmp    %r9,%rdx
jge    1ba0 <neiK+0xa80>
movsd  %xmm3,0x8(%r12,%rdx,8)
mov    0x0(%r13,%rdx,4),%esi
mov    %esi,0x4(%r13,%rdx,4)
jmp    1ba0 <neiK+0xa80>
mov    $0x1,%edx
testb  $0x1,0x20(%rsp)
jne    1b5c <neiK+0xa3c>
jmp    1b77 <neiK+0xa57>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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