void mi2K(double **x, int N, int K, double *psi, double *scal, double *mi_cr) {
  int i, k, ik, **n1, **n2;
  double *xc, dx;
  double **eps, *Eps;
  int *maxdim;
  double *dxy1, *dxy2;
  int *nn;
  int d;
  int BOX, BOX1;
  int **box, *lis;
  int **box1;
  int **lis1;
  int **mxi;
  double epsilon;
  int inveps;
  int dim = 2;
  double *phi;
  phi = (double *)malloc((K + 1) * sizeof(double));
  for (i = 1; i <= K; i++)
    phi[i] = psi[i] - (dim - 1) / ((double)(i));
  nn = (int *)malloc((K + 1) * sizeof(int));
  xc = (double *)malloc((dim + 1) * sizeof(double));
  BOX = 1;
  while (0.5 * BOX * BOX * K < N)
    BOX *= 2;
  epsilon = 4.0 / BOX;
  inveps = BOX / 4;
  BOX1 = N - 5;
  box1 = (int **)malloc((dim) * sizeof(int *));
  lis1 = (int **)malloc((dim) * sizeof(int *));
  mxi = (int **)malloc((dim) * sizeof(int *));
  for (d = 0; d < dim; d++) {
    box1[d] = (int *)malloc((BOX1 + 1) * sizeof(int));
    lis1[d] = (int *)malloc((N) * sizeof(int));
    mxi[d] = (int *)malloc((BOX1 + 1) * sizeof(int));
  }
  box = (int **)malloc((BOX) * sizeof(int *));
  for (i = 0; i < BOX; i++)
    box[i] = (int *)malloc((BOX) * sizeof(int));
  lis = (int *)malloc((N) * sizeof(int));
  eps = (double **)malloc((K) * sizeof(double *));
  Eps = (double *)malloc((K) * sizeof(double));
  n1 = (int **)malloc((K) * sizeof(int *));
  n2 = (int **)malloc((K) * sizeof(int *));
  maxdim = (int *)malloc((K) * sizeof(int));
  for (ik = 0; ik < K; ik++) {
    eps[ik] = (double *)malloc((dim) * sizeof(double));
    n1[ik] = (int *)malloc((dim) * sizeof(int));
    n2[ik] = (int *)malloc((dim) * sizeof(int));
    mi_cr[ik * 2] = 0;
    mi_cr[ik * 2 + 1] = 0;
  }
  dxy1 = (double *)malloc((K) * sizeof(double));
  dxy2 = (double *)malloc((K) * sizeof(double));
  make_box2(x, dim, N, 0, 1, BOX, inveps, box, lis);
  for (d = 0; d < dim; d++)
    make_box1(x[d], N, scal[d], BOX1, box1[d], lis1[d], mxi[d]);
  for (ik = 0; ik < K; ik++) {
    dxy1[ik] = dxy2[ik] = 0.0;
  }
  for (i = 0; i < N; i++) {
    for (d = 0; d < dim; d++)
      xc[d] = x[d][i];
    neiK(x, dim, 0, dim - 1, i, BOX, epsilon, K, box, lis, nn);
    for (ik = 0; ik < K; ik++) {
      Eps[ik] = 0;
      maxdim[ik] = -1;
      for (d = 0; d < dim; d++) {
        eps[ik][d] = 0;
        for (k = 1; k <= ik + 1; k++) {
          if ((dx = fabs(xc[d] - x[d][nn[k]])) > eps[ik][d])
            eps[ik][d] = dx;
        }
        if (eps[ik][d] > Eps[ik]) {
          Eps[ik] = eps[ik][d];
          maxdim[ik] = d;
        }
      }
    }
    for (ik = 0; ik < K; ik++) {
      for (d = 0; d < dim; d++) {
        n2[ik][d] =
            neiE1(x[d], i, scal[d], BOX1, eps[ik][d], box1[d], lis1[d], mxi[d]);
        if (d == maxdim[ik]) {
          n1[ik][d] = n2[ik][d];
          dxy1[ik] += psi[n1[ik][d]];
        } else {
          n1[ik][d] =
              neiE1(x[d], i, scal[d], BOX1, Eps[ik], box1[d], lis1[d], mxi[d]);
          dxy1[ik] += psi[n1[ik][d] + 1];
        }
        dxy2[ik] += psi[n2[ik][d]];
      }
    }
  }
  for (ik = 0; ik < K; ik++) {
    dxy1[ik] /= N;
    mi_cr[ik * 2] = psi[N] + psi[ik + 1] - dxy1[ik];
    dxy2[ik] /= N;
    mi_cr[ik * 2 + 1] = psi[N] + phi[ik + 1] - dxy2[ik];
  }
  free(xc);
  free(nn);
  for (i = 0; i < BOX; i++)
    free(box[i]);
  free(box);
  free(lis);
  for (d = 0; d < dim; d++) {
    free(box1[d]);
    free(lis1[d]);
    free(mxi[d]);
  }
  free(box1);
  free(lis1);
  free(mxi);
  for (ik = 0; ik < K; ik++) {
    free(eps[ik]);
    free(n1[ik]);
    free(n2[ik]);
  }
  free(eps);
  free(n1);
  free(n2);
  free(Eps);
  free(maxdim);
  free(dxy1);
  free(dxy2);
  free(phi);
}


x86 assembly (clang, -O0):
<mi2K>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xf8,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x2,-0xd8(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     11fd <mi2K+0x9d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xd8(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
cvtsi2sdl -0x34(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ac <mi2K+0x4c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x1,-0x98(%rbp)
cvtsi2sdl -0x98(%rbp),%xmm0
ff
movsd  0xdb7(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x98(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x18(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x14(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1285 <mi2K+0x125>
mov    -0x98(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1239 <mi2K+0xd9>
cvtsi2sdl -0x98(%rbp),%xmm1
ff
movsd  0xd73(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0xd4(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x9c(%rbp)
movslq -0xd8(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0xd8(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq -0xd8(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    13ac <mi2K+0x24c>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xb8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xc8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1310 <mi2K+0x1b0>
movslq -0x98(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1409 <mi2K+0x2a9>
movslq -0x98(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ca <mi2K+0x26a>
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    151d <mi2K+0x3bd>
movslq -0xd8(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0xd8(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0xd8(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1479 <mi2K+0x319>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0xd8(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x98(%rbp),%r9d
mov    -0xd4(%rbp),%r11d
mov    -0xa8(%rbp),%r10
mov    -0xb0(%rbp),%rax
xor    %ecx,%ecx
mov    $0x1,%r8d
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1080 <make_box2@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    161d <mi2K+0x4bd>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x14(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c(%rbp),%edx
mov    -0xb8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xc8(%rbp),%rax
movslq -0x94(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x1,%al
call   1040 <make_box1@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1592 <mi2K+0x432>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1661 <mi2K+0x501>
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1624 <mi2K+0x4c4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b32 <mi2K+0x9d2>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    16cc <mi2K+0x56c>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    167e <mi2K+0x51e>
mov    -0x10(%rbp),%rdi
mov    -0xd8(%rbp),%esi
mov    -0xd8(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%r8d
mov    -0x98(%rbp),%r9d
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%ebx
mov    -0xa8(%rbp),%r11
mov    -0xb0(%rbp),%r10
mov    -0x90(%rbp),%rax
xor    %edx,%edx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x1,%al
call   1050 <neiK@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18c4 <mi2K+0x764>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    18b1 <mi2K+0x751>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1837 <mi2K+0x6d7>
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x90(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x830(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1824 <mi2K+0x6c4>
movsd  -0x60(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1829 <mi2K+0x6c9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1795 <mi2K+0x635>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1898 <mi2K+0x738>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    189d <mi2K+0x73d>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1761 <mi2K+0x601>
jmp    18b6 <mi2K+0x756>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    172c <mi2K+0x5cc>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b1f <mi2K+0x9bf>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    1b0c <mi2K+0x9ac>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x34(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c(%rbp),%edx
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xc8(%rbp),%rax
movslq -0x94(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x2,%al
call   1060 <neiE1@plt>
mov    %eax,%edx
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
mov    -0x78(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1a02 <mi2K+0x8a2>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ac3 <mi2K+0x963>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x34(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x9c(%rbp),%edx
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xb8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xc8(%rbp),%rax
movslq -0x94(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x2,%al
call   1060 <neiE1@plt>
mov    %eax,%edx
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    18e1 <mi2K+0x781>
jmp    1b11 <mi2K+0x9b1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18cb <mi2K+0x76b>
jmp    1b24 <mi2K+0x9c4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1668 <mi2K+0x508>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1c11 <mi2K+0xab1>
cvtsi2sdl -0x14(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x14(%rbp),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xe0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b39 <mi2K+0x9d9>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1c5e <mi2K+0xafe>
mov    -0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c2d <mi2K+0xacd>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    1ceb <mi2K+0xb8b>
mov    -0xb8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1c80 <mi2K+0xb20>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d63 <mi2K+0xc03>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d16 <mi2K+0xbb6>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mi2K>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,0x68(%rsp)
mov    %r8,%r12
mov    %rcx,%rbp
mov    %edx,%ebx
mov    %esi,%r13d
mov    %rdi,0x38(%rsp)
lea    0x1(%rbx),%r15d
movslq %r15d,%r14
lea    0x0(,%r14,8),%rdi
call   1080 <malloc@plt>
mov    %rbx,0x20(%rsp)
test   %ebx,%ebx
jle    12d3 <mi2K+0x163>
mov    %r15d,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x2,%r8
jb     12a6 <mi2K+0x136>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbx
shr    %rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1e9b <mi2K+0xd2b>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xe06(%rip),%xmm0
xor    %esi,%esi
movapd 0xe0c(%rip),%xmm1
movdqa 0xe14(%rip),%xmm2
movdqa 0xe1c(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%rbp,%rsi,8),%xmm4
cvtdq2pd %xmm0,%xmm5
movapd %xmm1,%xmm6
divpd  %xmm5,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,0x8(%rax,%rsi,8)
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movupd 0x18(%rbp,%rsi,8),%xmm5
cvtdq2pd %xmm4,%xmm4
movapd %xmm1,%xmm6
divpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x18(%rax,%rsi,8)
add    $0x4,%rsi
paddd  %xmm3,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    1220 <mi2K+0xb0>
test   $0x1,%bl
je     129a <mi2K+0x12a>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd 0x0(%rbp,%rsi,1),%xmm1
cvtdq2pd %xmm0,%xmm0
movapd 0xdb3(%rip),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rsi,1)
cmp    %rdx,%r8
je     12d3 <mi2K+0x163>
or     $0x1,%r8
mov    %r8,%rdx
movsd  0xdb2(%rip),%xmm0
xchg   %ax,%ax
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    12b0 <mi2K+0x140>
mov    %rax,0x100(%rsp)
mov    %rbp,0x48(%rsp)
shl    $0x2,%r14
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,%rbx
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
xorps  %xmm3,%xmm3
cvtsi2sd %r13d,%xmm3
mov    $0x1,%eax
movsd  0xd5b(%rip),%xmm1
nopl   (%rax)
mov    %eax,%ebp
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    0x0(%rbp,%rbp,1),%eax
ucomisd %xmm2,%xmm3
ja     1310 <mi2K+0x1a0>
mov    %r12,0xd8(%rsp)
movapd %xmm3,0x120(%rsp)
mov    %ebp,%eax
shr    $0x2,%eax
mov    %rax,0x50(%rsp)
mov    %r13,0x10(%rsp)
movslq %r13d,%rax
lea    -0x10(,%rax,4),%r14
ff
mov    %rax,0xf0(%rsp)
lea    0x0(,%rax,4),%r15
mov    %r14,%rdi
movsd  %xmm4,0x40(%rsp)
call   1080 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x70(%rsp)
movsd  0xc9d(%rip),%xmm0
divsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x110(%rsp)
mov    %ebp,%r14d
lea    0x0(,%r14,8),%rdi
call   1080 <malloc@plt>
mov    %rax,%r12
shl    $0x2,%r14
cmp    $0x2,%ebp
mov    $0x1,%r13d
mov    %rbp,0xc8(%rsp)
cmovae %ebp,%r13d
xor    %ebp,%ebp
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1410 <mi2K+0x2a0>
mov    %r13,0xf8(%rsp)
mov    %r12,0x98(%rsp)
mov    0x10(%rsp),%rax
add    $0xfffffffb,%eax
mov    %eax,0xc(%rsp)
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    %rax,0x90(%rsp)
movslq 0x20(%rsp),%r12
lea    0x0(,%r12,8),%rbp
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %rbp,0x18(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,%r13
shl    $0x2,%r12
mov    %r12,%rdi
call   1080 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rax
mov    %eax,%r12d
test   %eax,%eax
jle    1504 <mi2K+0x394>
mov    %r12,%rdx
shl    $0x4,%rdx
xor    %ebp,%ebp
mov    0x68(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
mov    $0x10,%edi
call   1080 <malloc@plt>
mov    %rax,(%r14,%rbp,8)
mov    $0x8,%edi
call   1080 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
mov    $0x8,%edi
call   1080 <malloc@plt>
mov    %rax,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    14d0 <mi2K+0x360>
mov    %r12,0x28(%rsp)
mov    %r13,0xd0(%rsp)
mov    %r15,0xa0(%rsp)
mov    %r14,0xc0(%rsp)
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
sub    $0x8,%rsp
mov    0x40(%rsp),%r15
mov    %r15,%rdi
mov    $0x2,%esi
mov    0x18(%rsp),%rbp
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x1,%r8d
mov    0xd0(%rsp),%r9
xor    %eax,%eax
push   0x98(%rsp)
push   0xa8(%rsp)
push   0x68(%rsp)
call   1090 <make_box2@plt>
add    $0x20,%rsp
mov    (%r15),%rdi
mov    0xd8(%rsp),%r12
movsd  (%r12),%xmm0
mov    %ebp,%esi
mov    0xc(%rsp),%ebp
mov    %ebp,%edx
mov    0xa8(%rsp),%rcx
mov    0xe0(%rsp),%r8
mov    %r8,%r13
mov    0x80(%rsp),%r9
mov    %r9,%r14
mov    $0x1,%al
call   1040 <make_box1@plt>
mov    0x8(%r15),%rdi
movsd  0x8(%r12),%xmm0
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%rsi
mov    %ebp,%edx
mov    0x58(%rsp),%rcx
mov    0x78(%rsp),%r8
mov    0x70(%rsp),%r9
mov    $0x1,%al
call   1040 <make_box1@plt>
cmpl   $0x0,0x20(%rsp)
jle    1620 <mi2K+0x4b0>
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rbp
mov    0x18(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x10(%rsp),%rax
test   %eax,%eax
mov    0x48(%rsp),%rdi
jle    1b94 <mi2K+0xa24>
mov    %eax,%eax
mov    %rax,0x108(%rsp)
mov    0x28(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x118(%rsp)
xor    %r8d,%r8d
jmp    167d <mi2K+0x50d>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%r13
mov    %r9,%r14
mov    0x10(%rsp),%r8
add    $0x1,%r8
cmp    0x108(%rsp),%r8
je     1b94 <mi2K+0xa24>
mov    (%r15),%rax
mov    0x8(%r15),%rcx
movsd  (%rax,%r8,8),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    %r15,%rdi
mov    $0x2,%esi
xor    %edx,%edx
mov    $0x1,%ecx
mov    %r8,0x10(%rsp)
mov    0xc8(%rsp),%r9
movsd  0x110(%rsp),%xmm0
mov    $0x1,%al
push   %rbx
push   0x98(%rsp)
push   0xa8(%rsp)
mov    0x38(%rsp),%rbp
push   %rbp
call   1060 <neiK@plt>
mov    0x68(%rsp),%rdi
add    $0x20,%rsp
test   %ebp,%ebp
mov    %r14,%r9
mov    %r13,%r12
jle    1660 <mi2K+0x4f0>
mov    (%r15),%rax
mov    0x8(%r15),%rcx
mov    $0x1,%r9d
xor    %r10d,%r10d
mov    0x88(%rsp),%r11
movapd 0x939(%rip),%xmm3
movsd  0x50(%rsp),%xmm4
movsd  0xb8(%rsp),%xmm5
jmp    1748 <mi2K+0x5d8>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%r11,%r10,8)
add    $0x1,%r9
mov    %r8,%r10
cmp    0x28(%rsp),%r8
je     1910 <mi2K+0x7a0>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
lea    0x1(%r10),%r8
mov    0x40(%rsp),%rsi
movl   $0xffffffff,(%rsi,%r10,4)
ff
mov    0xc0(%rsp),%rsi
mov    (%rsi,%r10,8),%rbp
movq   $0x0,0x0(%rbp)
test   %r10,%r10
je     17f0 <mi2K+0x680>
mov    $0x1,%edi
pxor   %xmm2,%xmm2
jmp    17a2 <mi2K+0x632>
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%rdi,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x1,%rsi
je     17f9 <mi2K+0x689>
movslq (%rbx,%rdi,4),%rsi
movapd %xmm4,%xmm0
subsd  (%rax,%rsi,8),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm2,%xmm0
jbe    17c2 <mi2K+0x652>
movsd  %xmm0,0x0(%rbp)
movapd %xmm0,%xmm2
movslq 0x4(%rbx,%rdi,4),%rsi
movapd %xmm4,%xmm0
subsd  (%rax,%rsi,8),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm2,%xmm0
jbe    1790 <mi2K+0x620>
movsd  %xmm0,0x0(%rbp)
movapd %xmm0,%xmm2
jmp    1790 <mi2K+0x620>
cs nopw 0x0(%rax,%rax,1)
nop
pxor   %xmm2,%xmm2
mov    $0x1,%edi
test   $0x1,%r8b
je     181f <mi2K+0x6af>
movslq (%rbx,%rdi,4),%rsi
movapd %xmm4,%xmm0
subsd  (%rax,%rsi,8),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm2,%xmm0
jbe    181f <mi2K+0x6af>
movsd  %xmm0,0x0(%rbp)
movapd %xmm0,%xmm2
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
xorpd  %xmm0,%xmm0
jbe    183e <mi2K+0x6ce>
mov    0x40(%rsp),%rsi
movl   $0x0,(%rsi,%r10,4)
movapd %xmm2,%xmm0
movq   $0x0,0x8(%rbp)
mov    $0x1,%edi
test   %r10,%r10
je     18c0 <mi2K+0x750>
xorpd  %xmm1,%xmm1
jmp    1872 <mi2K+0x702>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdx,%rdi,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x1,%rsi
je     18c0 <mi2K+0x750>
movslq (%rbx,%rdi,4),%rsi
movapd %xmm5,%xmm2
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm1,%xmm2
jbe    1892 <mi2K+0x722>
movsd  %xmm2,0x8(%rbp)
movapd %xmm2,%xmm1
movslq 0x4(%rbx,%rdi,4),%rsi
movapd %xmm5,%xmm2
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm1,%xmm2
jbe    1860 <mi2K+0x6f0>
movsd  %xmm2,0x8(%rbp)
movapd %xmm2,%xmm1
jmp    1860 <mi2K+0x6f0>
cs nopw 0x0(%rax,%rax,1)
nop
test   $0x1,%r8b
je     18e6 <mi2K+0x776>
movslq (%rbx,%rdi,4),%rdx
movapd %xmm5,%xmm2
subsd  (%rcx,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm1,%xmm2
jbe    18e6 <mi2K+0x776>
movsd  %xmm2,0x8(%rbp)
movapd %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jbe    1730 <mi2K+0x5c0>
mov    0x40(%rsp),%rdx
movl   $0x1,(%rdx,%r10,4)
movapd %xmm1,%xmm0
jmp    1730 <mi2K+0x5c0>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0x20(%rsp)
mov    0xc(%rsp),%edx
mov    0x48(%rsp),%rdi
mov    %r14,%r9
mov    %r13,%r12
jle    1660 <mi2K+0x4f0>
xor    %ebp,%ebp
jmp    19a3 <mi2K+0x833>
xchg   %ax,%ax
mov    0xb0(%rsp),%rcx
mov    %eax,0x4(%rcx)
mov    0x48(%rsp),%rdi
mov    0x80(%rsp),%r9
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%rcx
mov    0x18(%rsp),%rsi
mov    0xc(%rsp),%edx
movsd  0x60(%rsp),%xmm0
movsd  0xe8(%rsp),%xmm1
cltq
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,2)
mov    0x50(%rsp),%rax
movslq 0x4(%rax),%rax
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,2)
add    $0x4,%rbp
cmp    %rbp,0x118(%rsp)
mov    0xe0(%rsp),%r12
je     1660 <mi2K+0x4f0>
mov    0xc0(%rsp),%rax
mov    (%rax,%rbp,2),%rax
mov    (%r15),%rdi
mov    0xd8(%rsp),%r13
movsd  0x0(%r13),%xmm0
mov    %rax,0x60(%rsp)
movsd  (%rax),%xmm1
mov    0x10(%rsp),%rsi
mov    0xa8(%rsp),%r15
mov    %r15,%rcx
mov    %r12,%r8
mov    %r9,%r14
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0xd0(%rsp),%rcx
mov    (%rcx,%rbp,2),%rcx
mov    %rcx,0x50(%rsp)
mov    %eax,(%rcx)
mov    0x40(%rsp),%rcx
mov    (%rcx,%rbp,1),%ecx
test   %ecx,%ecx
mov    %ecx,0xb8(%rsp)
je     1a80 <mi2K+0x910>
mov    %r12,%r8
mov    0x38(%rsp),%rax
mov    (%rax),%rdi
movsd  0x0(%r13),%xmm0
mov    0x88(%rsp),%rax
movsd  (%rax,%rbp,2),%xmm1
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%r12d
mov    %r12d,%edx
mov    %r15,%rcx
mov    %r14,%r9
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0xa0(%rsp),%rcx
mov    (%rcx,%rbp,2),%rcx
mov    %rcx,0xb0(%rsp)
mov    %eax,(%rcx)
add    $0x1,%eax
mov    0x58(%rsp),%rcx
mov    0x78(%rsp),%r14
mov    0x70(%rsp),%r15
mov    0x30(%rsp),%r10
mov    0x18(%rsp),%r9
mov    %r12d,%edx
jmp    1ab3 <mi2K+0x943>
nopl   0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rcx
mov    (%rcx,%rbp,2),%rcx
mov    %rcx,0xb0(%rsp)
mov    %eax,(%rcx)
mov    0x58(%rsp),%rcx
mov    0x78(%rsp),%r14
mov    0x70(%rsp),%r15
mov    0x30(%rsp),%r10
mov    0x18(%rsp),%r9
mov    0xc(%rsp),%edx
mov    0x38(%rsp),%r8
mov    0x10(%rsp),%rsi
mov    0x60(%rsp),%r11
cltq
mov    0x48(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm0
addsd  (%r10,%rbp,2),%xmm0
movsd  %xmm0,0x60(%rsp)
mov    0x50(%rsp),%r12
movslq (%r12),%rax
movsd  (%rdi,%rax,8),%xmm0
addsd  (%r9,%rbp,2),%xmm0
movsd  %xmm0,0xe8(%rsp)
mov    0x8(%r8),%rdi
movsd  0x8(%r13),%xmm0
movsd  0x8(%r11),%xmm1
mov    %r14,%r8
mov    %r15,%r9
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    %eax,0x4(%r12)
cmpl   $0x1,0xb8(%rsp)
01
je     1930 <mi2K+0x7c0>
mov    0x38(%rsp),%rax
mov    0x8(%rax),%rdi
movsd  0x8(%r13),%xmm0
mov    0x88(%rsp),%rax
movsd  (%rax,%rbp,2),%xmm1
mov    0x10(%rsp),%rsi
mov    0xc(%rsp),%r12d
mov    %r12d,%edx
mov    0x58(%rsp),%rcx
mov    %r14,%r8
mov    %r15,%r9
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0xb0(%rsp),%rcx
mov    %eax,0x4(%rcx)
add    $0x1,%eax
mov    0x48(%rsp),%rdi
mov    0x80(%rsp),%r9
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%rcx
mov    0x18(%rsp),%rsi
mov    %r12d,%edx
jmp    195b <mi2K+0x7eb>
cmpl   $0x0,0x20(%rsp)
mov    0x100(%rsp),%r14
movapd 0x120(%rsp),%xmm5
mov    0xc0(%rsp),%r12
jle    1c6e <mi2K+0xafe>
mov    0xf0(%rsp),%rsi
lea    (%rdi,%rsi,8),%r9
cmpl   $0x1,0x20(%rsp)
jne    1da1 <mi2K+0xc31>
xor    %r8d,%r8d
mov    0x18(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    0x30(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    %r8,%rax
shl    $0x4,%rax
mov    0x68(%rsp),%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    0x28(%rsp),%rbp
sub    %r8,%rbp
lea    (%r14,%r8,8),%r10
add    $0x8,%r10
lea    (%rdi,%r8,8),%rdi
add    $0x8,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,1),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rsi,%rcx,1)
movsd  (%r9),%xmm1
addsd  (%rdi,%rcx,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rax,%rcx,2)
movsd  (%rdx,%rcx,1),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rdx,%rcx,1)
movsd  (%r9),%xmm1
addsd  (%r10,%rcx,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,2)
add    $0x8,%rcx
add    $0xffffffffffffffff,%rbp
jne    1c20 <mi2K+0xab0>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0x98(%rsp),%r15
mov    0xf8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1c90 <mi2K+0xb20>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x0,0x20(%rsp)
mov    0xa0(%rsp),%r13
mov    0xd0(%rsp),%r15
mov    0x28(%rsp),%rbp
jle    1d45 <mi2K+0xbd5>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1d20 <mi2K+0xbb0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
shl    $0x4,%rcx
mov    0x68(%rsp),%rbp
add    %rbp,%rcx
lea    0x8(%rdi),%rax
lea    (%rdi,%rdx,8),%rdx
add    $0x8,%rdx
lea    (%rdi,%rsi,8),%rsi
add    $0x8,%rsi
cmp    %rbp,%rdx
seta   %r10b
cmp    %rcx,%rax
setb   %dl
cmp    %rbp,%rsi
seta   %al
cmp    %rcx,%r9
setb   %cl
xor    %r8d,%r8d
test   %dl,%r10b
jne    1bd2 <mi2K+0xa62>
and    %cl,%al
jne    1bd2 <mi2K+0xa62>
mov    0x28(%rsp),%r8
and    $0xfffffffe,%r8d
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %edx,%edx
mov    0x68(%rsp),%rsi
mov    0x30(%rsp),%rax
mov    0x18(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rdx,8)
movsd  (%r9),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%rdi,%rdx,8),%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm1,%xmm3
movupd (%rcx,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rcx,%rdx,8)
movsd  (%r9),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%r14,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
subpd  %xmm1,%xmm4
movapd %xmm3,%xmm1
unpcklpd %xmm4,%xmm1
movhlps %xmm3,%xmm4
movups %xmm4,0x10(%rsi)
movupd %xmm1,(%rsi)
add    $0x2,%rdx
add    $0x20,%rsi
cmp    %rdx,%r8
jne    1e20 <mi2K+0xcb0>
cmp    0x28(%rsp),%r8
jne    1bd2 <mi2K+0xa62>
jmp    1c6e <mi2K+0xafe>
movdqa 0x15d(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%bl
jne    1273 <mi2K+0x103>
jmp    129a <mi2K+0x12a>

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

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