void redK(double **x, int dim, 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;
  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, dim - 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] = (dim - 1) * psi[N] + psi[ik + 1] - dxy1[ik];
    dxy2[ik] /= N;
    mi_cr[ik * 2 + 1] = (dim - 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):
<redK>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0xf8,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x1c(%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    -0x1c(%rbp),%eax
jg     11f3 <redK+0x93>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x14(%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    11a5 <redK+0x45>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x14(%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  0xdc4(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x98(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1278 <redK+0x118>
mov    -0x98(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    122c <redK+0xcc>
cvtsi2sdl -0x98(%rbp),%xmm1
ff
movsd  0xd80(%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    -0x18(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x9c(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1393 <redK+0x233>
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 -0x18(%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    12fa <redK+0x19a>
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    13f0 <redK+0x290>
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    13b1 <redK+0x251>
movslq -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14fb <redK+0x39b>
movslq -0x14(%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 -0x14(%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 -0x14(%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    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%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    1460 <redK+0x300>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x98(%rbp),%r9d
mov    -0xd4(%rbp),%r11d
mov    -0xa8(%rbp),%r10
mov    -0xb0(%rbp),%rax
xor    %ecx,%ecx
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    -0x14(%rbp),%eax
jge    15f7 <redK+0x497>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%esi
mov    -0x30(%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    156f <redK+0x40f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    163b <redK+0x4db>
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    15fe <redK+0x49e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1afd <redK+0x99d>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16a3 <redK+0x543>
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    1658 <redK+0x4f8>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x34(%rbp),%r8d
mov    -0x98(%rbp),%r9d
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x1c(%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    -0x1c(%rbp),%eax
jge    1892 <redK+0x732>
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    -0x14(%rbp),%eax
jge    187f <redK+0x71f>
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     1805 <redK+0x6a5>
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 0x862(%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    17f2 <redK+0x692>
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    17f7 <redK+0x697>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1763 <redK+0x603>
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    1866 <redK+0x706>
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    186b <redK+0x70b>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1732 <redK+0x5d2>
jmp    1884 <redK+0x724>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16fd <redK+0x59d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1aea <redK+0x98a>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ad7 <redK+0x977>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x34(%rbp),%esi
mov    -0x30(%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    19cd <redK+0x86d>
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    -0x28(%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    1a8e <redK+0x92e>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x34(%rbp),%esi
mov    -0x30(%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    -0x28(%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    -0x28(%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    18af <redK+0x74f>
jmp    1adc <redK+0x97c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1899 <redK+0x739>
jmp    1aef <redK+0x98f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1642 <redK+0x4e2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c00 <redK+0xaa0>
cvtsi2sdl -0x18(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x18(%rbp),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xe0(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x3c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x10(%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    1b04 <redK+0x9a4>
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    1c4d <redK+0xaed>
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    1c1c <redK+0xabc>
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    -0x14(%rbp),%eax
jge    1cd7 <redK+0xb77>
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    1c6f <redK+0xb0f>
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    -0x1c(%rbp),%eax
jge    1d4f <redK+0xbef>
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    1d02 <redK+0xba2>
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):
<redK>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,%r12
mov    %r8,%rbp
mov    %ecx,%ebx
mov    %rdx,0x20(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,%r13
mov    0x170(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x1(%rbx),%r15d
movslq %r15d,%r14
lea    0x0(,%r14,8),%rdi
call   1080 <malloc@plt>
mov    %rbx,0x8(%rsp)
test   %ebx,%ebx
jle    12d7 <redK+0x167>
mov    0x30(%rsp),%rcx
add    $0xffffffff,%ecx
cvtsi2sd %ecx,%xmm0
mov    %r15d,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x2,%r8
jb     12b0 <redK+0x140>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbx
shr    %rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1ec4 <redK+0xd54>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xde5(%rip),%xmm2
xor    %esi,%esi
movdqa 0xdeb(%rip),%xmm3
movdqa 0xdf3(%rip),%xmm4
nopl   (%rax)
movupd 0x8(%rbp,%rsi,8),%xmm5
cvtdq2pd %xmm2,%xmm6
movapd %xmm1,%xmm7
divpd  %xmm6,%xmm7
subpd  %xmm7,%xmm5
movupd %xmm5,0x8(%rax,%rsi,8)
movdqa %xmm2,%xmm5
paddd  %xmm3,%xmm5
movupd 0x18(%rbp,%rsi,8),%xmm6
cvtdq2pd %xmm5,%xmm5
movapd %xmm1,%xmm7
divpd  %xmm5,%xmm7
subpd  %xmm7,%xmm6
movupd %xmm6,0x18(%rax,%rsi,8)
add    $0x4,%rsi
paddd  %xmm4,%xmm2
add    $0xfffffffffffffffe,%rdi
jne    1230 <redK+0xc0>
test   $0x1,%bl
je     12a2 <redK+0x132>
shl    $0x3,%rsi
or     $0x8,%rsi
cvtdq2pd %xmm2,%xmm2
movupd 0x0(%rbp,%rsi,1),%xmm3
divpd  %xmm2,%xmm1
subpd  %xmm1,%xmm3
movupd %xmm3,(%rax,%rsi,1)
cmp    %rdx,%r8
je     12d7 <redK+0x167>
or     $0x1,%r8
mov    %r8,%rdx
xchg   %ax,%ax
movsd  0x0(%rbp,%rdx,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
movapd %xmm0,%xmm3
divsd  %xmm2,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    12b0 <redK+0x140>
mov    %r13,0x48(%rsp)
mov    %r12,0xd0(%rsp)
mov    %rbp,0xc8(%rsp)
mov    %rax,0x90(%rsp)
shl    $0x2,%r14
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,%r15
movslq 0x30(%rsp),%rbp
lea    0x8(,%rbp,8),%rdi
call   1080 <malloc@plt>
mov    %rax,0xc0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rsp),%xmm0
mov    0x20(%rsp),%rbx
xorps  %xmm3,%xmm3
cvtsi2sd %ebx,%xmm3
mov    $0x1,%eax
movsd  0xd01(%rip),%xmm1
nop
mov    %eax,%ecx
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    (%rcx,%rcx,1),%eax
ucomisd %xmm2,%xmm3
ja     1340 <redK+0x1d0>
movq   %xmm4,0x28(%rsp)
mov    %rcx,0xa8(%rsp)
movapd %xmm3,0x120(%rsp)
movsd  0xcc7(%rip),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    %rbp,0xe8(%rsp)
lea    0x0(,%rbp,8),%rbp
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %rbp,0xe0(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,%r14
movslq %ebx,%rax
mov    %rax,0x98(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%r12d
test   %eax,%eax
jle    143d <redK+0x2cd>
mov    0x98(%rsp),%rax
lea    -0x10(,%rax,4),%rbx
ff
lea    0x0(,%rax,4),%r13
xor    %ebp,%ebp
xchg   %ax,%ax
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    0x88(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
mov    %r13,%rdi
call   1080 <malloc@plt>
mov    0x80(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1400 <redK+0x290>
mov    %r12,0x40(%rsp)
mov    %r14,0x78(%rsp)
movsd  0xa0(%rsp),%xmm0
divsd  0x28(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0xa8(%rsp),%rbp
mov    %ebp,%eax
shr    $0x2,%eax
mov    %rax,0xd8(%rsp)
mov    0x20(%rsp),%rax
add    $0xfffffffb,%eax
mov    %eax,0x50(%rsp)
mov    %ebp,%r14d
lea    0x0(,%r14,8),%rdi
call   1080 <malloc@plt>
mov    %rax,%r12
shl    $0x2,%r14
cmp    $0x2,%ebp
mov    $0x1,%ebx
cmovae %ebp,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    14b0 <redK+0x340>
mov    %rbx,0xf8(%rsp)
mov    %r12,0xb8(%rsp)
mov    0x98(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   1080 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    0x8(%rsp),%r12
movslq %r12d,%rbp
lea    0x0(,%rbp,8),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x68(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,%rbx
shl    $0x2,%rbp
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r12d,%r14d
test   %r12d,%r12d
mov    0xe8(%rsp),%r12
mov    0xe0(%rsp),%r13
jle    15b7 <redK+0x447>
shl    $0x2,%r12
mov    %r14,%rdx
shl    $0x4,%rdx
xor    %ebp,%ebp
mov    0x58(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
call   1080 <malloc@plt>
mov    0x60(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
mov    %r12,%rdi
call   1080 <malloc@plt>
mov    0x70(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
mov    %r12,%rdi
call   1080 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1580 <redK+0x410>
mov    %r14,(%rsp)
mov    %rbx,0xf0(%rsp)
mov    0x18(%rsp),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    0x30(%rsp),%r14
lea    -0x1(%r14),%r8d
sub    $0x8,%rsp
mov    0x50(%rsp),%rdi
mov    %r14d,%esi
mov    0x28(%rsp),%rdx
xor    %ecx,%ecx
mov    %r8d,0x5c(%rsp)
mov    0xb0(%rsp),%r9
xor    %eax,%eax
push   0xb8(%rsp)
push   0xc8(%rsp)
push   0xf0(%rsp)
call   1090 <make_box2@plt>
add    $0x20,%rsp
test   %r14d,%r14d
mov    0x88(%rsp),%r12
mov    0x80(%rsp),%r13
mov    0x78(%rsp),%rsi
mov    0xd0(%rsp),%rbp
mov    0x50(%rsp),%edx
jle    16a7 <redK+0x537>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x48(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
movsd  0x0(%rbp,%rbx,8),%xmm0
mov    (%r12,%rbx,8),%rcx
mov    0x0(%r13,%rbx,8),%r8
mov    (%rsi,%rbx,8),%r9
mov    0x20(%rsp),%rsi
mov    $0x1,%al
mov    %edx,%ebp
call   1040 <make_box1@plt>
mov    %ebp,%edx
mov    0xd0(%rsp),%rbp
mov    0x40(%rsp),%rax
mov    0x78(%rsp),%rsi
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1660 <redK+0x4f0>
cmpl   $0x0,0x8(%rsp)
mov    0xc8(%rsp),%r9
jle    16e6 <redK+0x576>
mov    (%rsp),%rax
lea    0x0(,%rax,8),%rbx
mov    0x10(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
mov    %r9,%rbp
call   1050 <memset@plt>
mov    0x38(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    %rbp,%r9
mov    0x20(%rsp),%rax
test   %eax,%eax
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%rbp
jle    1b80 <redK+0xa10>
mov    %eax,%eax
mov    %rax,0x118(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x108(%rsp)
mov    %r13d,%ebx
and    $0x3,%ebx
and    $0xfffffffc,%r13d
mov    %r13,0x100(%rsp)
xor    %r10d,%r10d
mov    %rbx,0x110(%rsp)
jmp    175f <redK+0x5ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
cmp    0x118(%rsp),%r10
mov    0x40(%rsp),%r13
mov    0x110(%rsp),%rbx
je     1b80 <redK+0xa10>
mov    %r9,%r12
test   %r14d,%r14d
mov    0xc0(%rsp),%rdx
mov    0x48(%rsp),%rdi
jle    1818 <redK+0x6a8>
cmpq   $0x3,0x108(%rsp)
jae    1790 <redK+0x620>
xor    %eax,%eax
jmp    17eb <redK+0x67b>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x100(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    0x8(%rdi,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
mov    0x10(%rdi,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rax,8)
mov    0x18(%rdi,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    17a0 <redK+0x630>
test   %rbx,%rbx
je     1818 <redK+0x6a8>
lea    (%rdx,%rax,8),%rcx
lea    (%rdi,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r10,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1800 <redK+0x690>
mov    %r14d,%esi
xor    %edx,%edx
mov    0x54(%rsp),%ecx
mov    %r10,0x18(%rsp)
mov    0x18(%rsp),%r8
mov    0xa8(%rsp),%r9
movsd  0xa0(%rsp),%xmm0
mov    $0x1,%al
push   %r15
push   0xb8(%rsp)
push   0xc8(%rsp)
mov    0x20(%rsp),%rbx
push   %rbx
call   1060 <neiK@plt>
mov    0x38(%rsp),%r10
add    $0x20,%rsp
test   %ebx,%ebx
mov    0x10(%rsp),%rbp
mov    %r12,%r9
jle    1740 <redK+0x5d0>
mov    $0x1,%r8d
xor    %ecx,%ecx
mov    0x40(%rsp),%r10
mov    0xc0(%rsp),%r11
mov    (%rsp),%rdx
movapd 0x79d(%rip),%xmm4
jmp    18be <redK+0x74e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x68(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    (%rsp),%rdx
add    $0x1,%r8
mov    %r9,%rcx
cmp    %rdx,%r9
je     19c0 <redK+0x850>
lea    0x1(%rcx),%r9
mov    0x68(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
mov    0x28(%rsp),%rax
movl   $0xffffffff,(%rax,%rcx,4)
test   %r14d,%r14d
jle    18ae <redK+0x73e>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    0x60(%rsp),%rax
mov    (%rax,%rcx,8),%rdi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
mov    0x48(%rsp),%r13
jmp    1909 <redK+0x799>
add    $0x1,%rbp
cmp    %r10,%rbp
je     18a0 <redK+0x730>
movq   $0x0,(%rdi,%rbp,8)
movsd  (%r11,%rbp,8),%xmm1
mov    0x0(%r13,%rbp,8),%rbx
mov    $0x1,%eax
pxor   %xmm2,%xmm2
test   %rcx,%rcx
jne    1972 <redK+0x802>
test   $0x1,%r9b
je     194c <redK+0x7dc>
movslq (%r15,%rax,4),%rax
subsd  (%rbx,%rax,8),%xmm1
andpd  %xmm4,%xmm1
ucomisd %xmm2,%xmm1
jbe    194c <redK+0x7dc>
movsd  %xmm1,(%rdi,%rbp,8)
movapd %xmm1,%xmm2
ucomisd %xmm0,%xmm2
jbe    1900 <redK+0x790>
mov    0x28(%rsp),%rax
mov    %ebp,(%rax,%rcx,4)
movapd %xmm2,%xmm0
jmp    1900 <redK+0x790>
lea    (%rsi,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     192a <redK+0x7ba>
movslq (%r15,%rax,4),%rdx
movapd %xmm1,%xmm3
subsd  (%rbx,%rdx,8),%xmm3
andpd  %xmm4,%xmm3
ucomisd %xmm2,%xmm3
jbe    1992 <redK+0x822>
movsd  %xmm3,(%rdi,%rbp,8)
movapd %xmm3,%xmm2
movslq 0x4(%r15,%rax,4),%rdx
movapd %xmm1,%xmm3
subsd  (%rbx,%rdx,8),%xmm3
andpd  %xmm4,%xmm3
ucomisd %xmm2,%xmm3
jbe    1960 <redK+0x7f0>
movsd  %xmm3,(%rdi,%rbp,8)
movapd %xmm3,%xmm2
jmp    1960 <redK+0x7f0>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%rbp
mov    0x50(%rsp),%ebx
mov    0x18(%rsp),%r10
mov    %r12,%r9
jle    1740 <redK+0x5d0>
xor    %r13d,%r13d
jmp    1a03 <redK+0x893>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    (%rsp),%r13
mov    0x30(%rsp),%r14
je     1740 <redK+0x5d0>
test   %r14d,%r14d
jle    19f0 <redK+0x880>
mov    0x60(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    %rax,0xd8(%rsp)
xor    %r14d,%r14d
jmp    1ad2 <redK+0x962>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%r14,8),%rdi
movsd  (%r12,%r14,8),%xmm0
mov    0x68(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
mov    0x18(%rsp),%r12
mov    %r12d,%esi
mov    %rdx,%rbp
mov    %ebx,%edx
mov    0x20(%rsp),%rcx
mov    0xe8(%rsp),%r8
mov    0xe0(%rsp),%r9
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    %rbp,%rdx
mov    0x70(%rsp),%rcx
mov    (%rcx,%r13,8),%rcx
mov    %eax,(%rcx,%r14,4)
add    $0x1,%eax
mov    0xc8(%rsp),%r9
mov    0x10(%rsp),%rbp
mov    %r12,%r10
cltq
movsd  (%r9,%rax,8),%xmm0
mov    0x38(%rsp),%rax
addsd  (%rax,%r13,8),%xmm0
movsd  %xmm0,(%rax,%r13,8)
movslq (%rdx,%r14,4),%rax
movsd  (%r9,%rax,8),%xmm0
addsd  0x0(%rbp,%r13,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r13,8)
add    $0x1,%r14
cmp    %r14,0x40(%rsp)
je     19f0 <redK+0x880>
mov    0x48(%rsp),%rbp
mov    0x0(%rbp,%r14,8),%rdi
mov    0xd0(%rsp),%r12
movsd  (%r12,%r14,8),%xmm0
mov    0xd8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
mov    0x88(%rsp),%rax
mov    (%rax,%r14,8),%rcx
mov    0x80(%rsp),%rax
mov    (%rax,%r14,8),%r8
mov    0x78(%rsp),%rax
mov    (%rax,%r14,8),%r9
mov    %r10d,%esi
mov    %ebx,%edx
mov    %rcx,0x20(%rsp)
mov    %r8,0xe8(%rsp)
mov    %r9,0xe0(%rsp)
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0xf0(%rsp),%rcx
mov    (%rcx,%r13,8),%rdx
mov    %eax,(%rdx,%r14,4)
mov    0x28(%rsp),%rcx
mov    (%rcx,%r13,4),%ecx
cmp    %rcx,%r14
jne    1a30 <redK+0x8c0>
mov    0x70(%rsp),%rcx
mov    (%rcx,%r13,8),%rcx
mov    %eax,(%rcx,%r14,4)
mov    0xc8(%rsp),%r9
mov    0x10(%rsp),%rbp
mov    0x18(%rsp),%r10
jmp    1a92 <redK+0x922>
cmpl   $0x0,0x8(%rsp)
movapd 0x120(%rsp),%xmm7
jle    1c55 <redK+0xae5>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x54(%rsp),%xmm0
mov    0x98(%rsp),%rax
lea    (%r9,%rax,8),%r8
cmpl   $0x1,0x8(%rsp)
jne    1db2 <redK+0xc42>
xor    %ecx,%ecx
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
mov    %rcx,%rax
shl    $0x4,%rax
mov    0x58(%rsp),%rdi
add    %rax,%rdi
add    $0x8,%rdi
mov    (%rsp),%rbp
sub    %rcx,%rbp
mov    0x90(%rsp),%rax
lea    (%rax,%rcx,8),%rbx
add    $0x8,%rbx
lea    (%r9,%rcx,8),%rcx
add    $0x8,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movsd  (%rsi,%rax,1),%xmm1
divsd  %xmm7,%xmm1
movsd  %xmm1,(%rsi,%rax,1)
movsd  (%r8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rcx,%rax,1),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rdi,%rax,2)
movsd  (%rdx,%rax,1),%xmm1
divsd  %xmm7,%xmm1
movsd  %xmm1,(%rdx,%rax,1)
movsd  (%r8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rbx,%rax,1),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,2)
add    $0x8,%rax
add    $0xffffffffffffffff,%rbp
jne    1c00 <redK+0xa90>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0xb8(%rsp),%r15
mov    0xf8(%rsp),%rbp
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1c80 <redK+0xb10>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
test   %r14d,%r14d
mov    0x88(%rsp),%rbp
mov    0x80(%rsp),%r14
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%r12
jle    1cf5 <redK+0xb85>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1cd0 <redK+0xb60>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x60(%rsp),%r15
mov    0xf0(%rsp),%r14
mov    (%rsp),%rbp
jle    1d54 <redK+0xbe4>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1d30 <redK+0xbc0>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x90(%rsp),%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    (%rsp),%rdx
mov    %rdx,%rcx
shl    $0x4,%rcx
mov    %rax,%rsi
mov    0x58(%rsp),%rdi
add    %rdi,%rcx
lea    0x8(%r9),%rax
lea    (%r9,%rdx,8),%rdx
add    $0x8,%rdx
lea    (%r9,%rsi,8),%rsi
add    $0x8,%rsi
cmp    %rdi,%rdx
seta   %bl
cmp    %rcx,%rax
setb   %dl
cmp    %rdi,%rsi
seta   %al
cmp    %rcx,%r8
setb   %sil
xor    %ecx,%ecx
test   %dl,%bl
jne    1bb6 <redK+0xa46>
and    %sil,%al
jne    1bb6 <redK+0xa46>
mov    (%rsp),%rcx
and    $0xfffffffe,%ecx
movapd %xmm7,%xmm1
unpcklpd %xmm7,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
xor    %edx,%edx
mov    0x58(%rsp),%rsi
mov    0x90(%rsp),%rax
mov    0x38(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rdi,%rdx,8),%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,(%rdi,%rdx,8)
movsd  (%r8),%xmm4
unpcklpd %xmm4,%xmm4
movupd 0x8(%r9,%rdx,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
subpd  %xmm3,%xmm4
movupd 0x0(%rbp,%rdx,8),%xmm3
divpd  %xmm1,%xmm3
movupd %xmm3,0x0(%rbp,%rdx,8)
movsd  (%r8),%xmm5
unpcklpd %xmm5,%xmm5
movupd 0x8(%rax,%rdx,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
subpd  %xmm3,%xmm5
movapd %xmm4,%xmm3
unpcklpd %xmm5,%xmm3
movhlps %xmm4,%xmm5
movups %xmm5,0x10(%rsi)
movupd %xmm3,(%rsi)
add    $0x2,%rdx
add    $0x20,%rsi
cmp    %rdx,%rcx
jne    1e40 <redK+0xcd0>
cmp    (%rsp),%rcx
jne    1bb6 <redK+0xa46>
jmp    1c55 <redK+0xae5>
movdqa 0x134(%rip),%xmm2
xor    %esi,%esi
test   $0x1,%bl
jne    1283 <redK+0x113>
jmp    12a2 <redK+0x132>

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

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