void mi_d(double **x, int dim, int N, int K, float *mi_cr, double *psi,
          double *phi, double minx, double maxx, double miny, double maxy) {
  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 scal[2];
  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;
  scal[0] = BOX1 / (maxx - minx);
  scal[1] = BOX1 / (maxy - miny);
  box1 = (int **)malloc((dim) * sizeof(int *));
  lis1 = (int **)malloc((dim) * sizeof(int *));
  mxi = (int **)malloc((dim) * sizeof(int *));
  for (d = 0; d < dim; d++) {
    box1[d] = (int *)malloc((BOX1 + 1) * sizeof(int));
    lis1[d] = (int *)malloc((N) * sizeof(int));
    mxi[d] = (int *)malloc((BOX1 + 1) * sizeof(int));
  }
  box = (int **)malloc((BOX) * sizeof(int *));
  for (i = 0; i < BOX; i++)
    box[i] = (int *)malloc((BOX) * sizeof(int));
  lis = (int *)malloc((N) * sizeof(int));
  eps = (double **)malloc((K) * sizeof(double *));
  Eps = (double *)malloc((K) * sizeof(double));
  n1 = (int **)malloc((K) * sizeof(int *));
  n2 = (int **)malloc((K) * sizeof(int *));
  maxdim = (int *)malloc((K) * sizeof(int));
  for (ik = 0; ik < K; ik++) {
    eps[ik] = (double *)malloc((dim) * sizeof(double));
    n1[ik] = (int *)malloc((dim) * sizeof(int));
    n2[ik] = (int *)malloc((dim) * sizeof(int));
    mi_cr[ik * 2] = 0;
    mi_cr[ik * 2 + 1] = 0;
  }
  dxy1 = (double *)malloc((K) * sizeof(double));
  dxy2 = (double *)malloc((K) * sizeof(double));
  make_box2(x, dim, N, 0, 1, BOX, inveps, box, lis);
  for (d = 0; d < dim; d++) {
    make_box1(x[d], N, scal[d & 1], 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, 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 & 1], 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 & 1], 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] = (float)((dim - 1) * psi[N] + psi[ik + 1] - dxy1[ik]);
    dxy2[ik] /= N;
    mi_cr[ik * 2 + 1] = (float)((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);
}


x86 assembly (clang, -O0):
<mi_d>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x128,%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)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x1,-0xb8(%rbp)
cvtsi2sdl -0xb8(%rbp),%xmm0
ff
movsd  0xe1e(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0xb8(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    121e <mi_d+0xbe>
mov    -0xb8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    11d2 <mi_d+0x72>
cvtsi2sdl -0xb8(%rbp),%xmm1
ff
movsd  0xdda(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0xb8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0xf4(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0xbc(%rbp)
cvtsi2sdl -0xbc(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
cvtsi2sdl -0xbc(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm1
subsd  -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1375 <mi_d+0x215>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xd8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xe0(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xe8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    12dc <mi_d+0x17c>
movslq -0xb8(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    13d2 <mi_d+0x272>
movslq -0xb8(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xc8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1393 <mi_d+0x233>
movslq -0x18(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x90(%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    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14e9 <mi_d+0x389>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    144b <mi_d+0x2eb>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0xb8(%rbp),%r9d
mov    -0xf4(%rbp),%r11d
mov    -0xc8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %ecx,%ecx
mov    $0x1,%r8d
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1080 <make_box2@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15ea <mi_d+0x48a>
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%esi
mov    -0xb4(%rbp),%eax
and    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
mov    -0xbc(%rbp),%edx
mov    -0xd8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xe0(%rbp),%rax
movslq -0xb4(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xe8(%rbp),%rax
movslq -0xb4(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x1,%al
call   1040 <make_box1@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    155e <mi_d+0x3fe>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1631 <mi_d+0x4d1>
mov    -0xa8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15f1 <mi_d+0x491>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1b27 <mi_d+0x9c7>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1699 <mi_d+0x539>
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    164e <mi_d+0x4ee>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x54(%rbp),%r8d
mov    -0xb8(%rbp),%r9d
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x1c(%rbp),%ebx
mov    -0xc8(%rbp),%r11
mov    -0xd0(%rbp),%r10
mov    -0xb0(%rbp),%rax
xor    %edx,%edx
mov    $0x1,%ecx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x1,%al
call   1050 <neiK@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    18a5 <mi_d+0x745>
mov    -0x90(%rbp),%rax
movslq -0x5c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1892 <mi_d+0x732>
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1809 <mi_d+0x6a9>
mov    -0x78(%rbp),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x864(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    17f6 <mi_d+0x696>
movsd  -0x80(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17fb <mi_d+0x69b>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1761 <mi_d+0x601>
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1879 <mi_d+0x719>
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    187e <mi_d+0x71e>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    172d <mi_d+0x5cd>
jmp    1897 <mi_d+0x737>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16f2 <mi_d+0x592>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b14 <mi_d+0x9b4>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b01 <mi_d+0x9a1>
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x54(%rbp),%esi
mov    -0xb4(%rbp),%eax
and    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
mov    -0xbc(%rbp),%edx
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xe0(%rbp),%rax
movslq -0xb4(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xe8(%rbp),%rax
movslq -0xb4(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x2,%al
call   1060 <neiE1@plt>
mov    %eax,%edx
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb4(%rbp),%eax
mov    -0x98(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    19ed <mi_d+0x88d>
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xb4(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ab8 <mi_d+0x958>
mov    -0x10(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x54(%rbp),%esi
mov    -0xb4(%rbp),%eax
and    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
mov    -0xbc(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0xe0(%rbp),%rax
movslq -0xb4(%rbp),%r8
mov    (%rax,%r8,8),%r8
mov    -0xe8(%rbp),%rax
movslq -0xb4(%rbp),%r9
mov    (%rax,%r9,8),%r9
mov    $0x2,%al
call   1060 <neiE1@plt>
mov    %eax,%edx
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xb4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xb4(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xb4(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    18c2 <mi_d+0x762>
jmp    1b06 <mi_d+0x9a6>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    18ac <mi_d+0x74c>
jmp    1b19 <mi_d+0x9b9>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1638 <mi_d+0x4d8>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c35 <mi_d+0xad5>
cvtsi2sdl -0x18(%rbp),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x5c(%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    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cvtsi2sdl -0x18(%rbp),%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x5c(%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    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1b2e <mi_d+0x9ce>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0xb8(%rbp),%eax
jge    1c82 <mi_d+0xb22>
mov    -0xc8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1c51 <mi_d+0xaf1>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d0c <mi_d+0xbac>
mov    -0xd8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1ca4 <mi_d+0xb44>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1d87 <mi_d+0xc27>
mov    -0x88(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1d37 <mi_d+0xbd7>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
add    $0x128,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mi_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
movaps %xmm3,0xd0(%rsp)
movapd %xmm2,0xf0(%rsp)
movaps %xmm1,0x80(%rsp)
movaps %xmm0,0xe0(%rsp)
mov    %r9,0x30(%rsp)
mov    %r8,0x90(%rsp)
mov    %edx,%r15d
mov    %esi,%r14d
mov    %rdi,0x78(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    %rcx,0x8(%rsp)
movslq %ecx,%rbx
lea    0x4(,%rbx,4),%rdi
call   1080 <malloc@plt>
mov    %rax,%rbp
movslq %r14d,%r13
lea    0x8(,%r13,8),%rdi
call   1080 <malloc@plt>
mov    %rax,0xc0(%rsp)
mov    %rbx,0xc8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
xorps  %xmm3,%xmm3
cvtsi2sd %r15d,%xmm3
mov    $0x1,%eax
movsd  0xde2(%rip),%xmm1
xchg   %ax,%ax
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     1220 <mi_d+0xb0>
movsd  %xmm4,0x28(%rsp)
mov    %rcx,0xa8(%rsp)
movapd %xmm3,0x150(%rsp)
lea    -0x5(%r15),%eax
mov    %eax,0x4(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xd98(%rip),%xmm1
movsd  %xmm1,0xa0(%rsp)
movapd 0x80(%rsp),%xmm1
unpcklpd 0xd0(%rsp),%xmm1
movapd 0xe0(%rsp),%xmm2
unpcklpd 0xf0(%rsp),%xmm2
subpd  %xmm2,%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm1,%xmm0
movapd %xmm0,0x140(%rsp)
lea    0x0(,%r13,8),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %rbx,0xe0(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,%r12
mov    %r15,0x80(%rsp)
movslq %r15d,%rax
mov    %rax,0x98(%rsp)
mov    %r14,0x108(%rsp)
mov    %r14d,%r15d
mov    %r13,0xf0(%rsp)
test   %r13d,%r13d
jle    1367 <mi_d+0x1f7>
mov    0x98(%rsp),%rax
lea    -0x10(,%rax,4),%r14
ff
lea    0x0(,%rax,4),%r13
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    0x60(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
mov    %r13,%rdi
call   1080 <malloc@plt>
mov    0x38(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,(%r12,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1330 <mi_d+0x1c0>
mov    %r15,0x40(%rsp)
mov    %r12,0x68(%rsp)
movsd  0xa0(%rsp),%xmm0
divsd  0x28(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0xa8(%rsp),%rbx
mov    %ebx,%eax
shr    $0x2,%eax
mov    %rax,0xd0(%rsp)
mov    %ebx,%r13d
lea    0x0(,%r13,8),%rdi
call   1080 <malloc@plt>
mov    %rax,%r14
shl    $0x2,%r13
cmp    $0x2,%ebx
mov    $0x1,%r15d
cmovae %ebx,%r15d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rdi
call   1080 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    13d0 <mi_d+0x260>
mov    %r15,0x118(%rsp)
mov    %r14,0xb8(%rsp)
mov    0x98(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   1080 <malloc@plt>
mov    %rax,0xb0(%rsp)
mov    0xc8(%rsp),%r15
lea    0x0(,%r15,8),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %rbx,0x70(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,%r13
lea    0x0(,%r15,4),%rdi
call   1080 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%r14d
test   %r15d,%r15d
mov    0x90(%rsp),%rdi
mov    0xf0(%rsp),%r15
mov    0xe0(%rsp),%r12
jle    14e8 <mi_d+0x378>
shl    $0x2,%r15
lea    0x0(,%r14,8),%rdx
xor    %ebx,%ebx
xor    %esi,%esi
call   1050 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rdi
call   1080 <malloc@plt>
mov    0x48(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    0x58(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
mov    %r15,%rdi
call   1080 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    14b0 <mi_d+0x340>
mov    %r14,0x10(%rsp)
mov    %r13,0x110(%rsp)
mov    0x70(%rsp),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x18(%rsp)
sub    $0x8,%rsp
mov    0x80(%rsp),%rbx
mov    %rbx,%rdi
mov    0x110(%rsp),%r15
mov    %r15d,%esi
mov    0x88(%rsp),%rdx
xor    %ecx,%ecx
mov    $0x1,%r8d
mov    0xb0(%rsp),%r9
xor    %eax,%eax
push   0xb8(%rsp)
push   0xc8(%rsp)
push   0xe8(%rsp)
call   1090 <make_box2@plt>
add    $0x20,%rsp
test   %r15d,%r15d
mov    0x60(%rsp),%r12
mov    0x38(%rsp),%rsi
mov    0x68(%rsp),%r9
mov    0x4(%rsp),%r13d
jle    15d9 <mi_d+0x469>
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%r14,8),%rdi
mov    %r14d,%eax
and    $0x1,%eax
movsd  0x140(%rsp,%rax,8),%xmm0
mov    (%r12,%r14,8),%rcx
mov    (%rsi,%r14,8),%r8
mov    (%r9,%r14,8),%r9
mov    0x80(%rsp),%rsi
mov    %r13d,%edx
mov    $0x1,%al
call   1040 <make_box1@plt>
mov    0x40(%rsp),%rax
mov    0x38(%rsp),%rsi
mov    0x68(%rsp),%r9
add    $0x1,%r14
cmp    %r14,%rax
jne    1590 <mi_d+0x420>
cmpl   $0x0,0x8(%rsp)
jle    160b <mi_d+0x49b>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,8),%r14
mov    0x18(%rsp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
mov    0x20(%rsp),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1050 <memset@plt>
mov    0x80(%rsp),%rax
test   %eax,%eax
mov    0x40(%rsp),%r13
jle    1aa8 <mi_d+0x938>
mov    %eax,%eax
mov    %rax,0x138(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x128(%rsp)
mov    %r13d,%edi
and    $0x3,%edi
and    $0xfffffffc,%r13d
mov    %r13,0x120(%rsp)
xor    %r8d,%r8d
mov    %rdi,0x130(%rsp)
jmp    1689 <mi_d+0x519>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x70(%rsp),%r8
add    $0x1,%r8
cmp    0x138(%rsp),%r8
mov    0x40(%rsp),%r13
mov    0x78(%rsp),%rbx
mov    0x130(%rsp),%rdi
je     1aa8 <mi_d+0x938>
test   %r15d,%r15d
mov    0xc0(%rsp),%rdx
mov    0xb8(%rsp),%r10
jle    1748 <mi_d+0x5d8>
cmpq   $0x3,0x128(%rsp)
jae    16c0 <mi_d+0x550>
xor    %eax,%eax
jmp    171b <mi_d+0x5ab>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x120(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    0x8(%rbx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
mov    0x10(%rbx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rax,8)
mov    0x18(%rbx,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    16d0 <mi_d+0x560>
test   %rdi,%rdi
je     1748 <mi_d+0x5d8>
lea    (%rdx,%rax,8),%rcx
lea    (%rbx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1730 <mi_d+0x5c0>
mov    %rbx,%rdi
mov    %r15d,%esi
xor    %edx,%edx
mov    $0x1,%ecx
mov    %r8,0x70(%rsp)
mov    0xa8(%rsp),%r9
movsd  0xa0(%rsp),%xmm0
mov    $0x1,%al
push   %rbp
push   0xb8(%rsp)
push   %r10
mov    0x20(%rsp),%rbx
push   %rbx
call   1060 <neiK@plt>
add    $0x20,%rsp
test   %ebx,%ebx
mov    0x10(%rsp),%rcx
jle    1660 <mi_d+0x4f0>
mov    $0x1,%r8d
xor    %r10d,%r10d
mov    0x40(%rsp),%r11
mov    0xc0(%rsp),%r14
mov    0x48(%rsp),%r13
movapd 0x85a(%rip),%xmm4
jmp    17e0 <mi_d+0x670>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rax
movsd  %xmm0,(%rax,%r10,8)
mov    0x10(%rsp),%rcx
add    $0x1,%r8
mov    %r9,%r10
cmp    %rcx,%r9
je     18f0 <mi_d+0x780>
lea    0x1(%r10),%r9
mov    0x50(%rsp),%rax
movq   $0x0,(%rax,%r10,8)
mov    0x28(%rsp),%rax
movl   $0xffffffff,(%rax,%r10,4)
ff
test   %r15d,%r15d
jle    17d0 <mi_d+0x660>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    0x0(%r13,%r10,8),%rdi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    1829 <mi_d+0x6b9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r11,%rbx
je     17c0 <mi_d+0x650>
movq   $0x0,(%rdi,%rbx,8)
movsd  (%r14,%rbx,8),%xmm1
mov    0x78(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    $0x1,%edx
xorpd  %xmm2,%xmm2
test   %r10,%r10
jne    18a2 <mi_d+0x732>
test   $0x1,%r9b
je     1871 <mi_d+0x701>
movslq 0x0(%rbp,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm1
andpd  %xmm4,%xmm1
ucomisd %xmm2,%xmm1
jbe    1871 <mi_d+0x701>
movsd  %xmm1,(%rdi,%rbx,8)
movapd %xmm1,%xmm2
ucomisd %xmm0,%xmm2
jbe    1820 <mi_d+0x6b0>
mov    0x28(%rsp),%rax
mov    %ebx,(%rax,%r10,4)
movapd %xmm2,%xmm0
jmp    1820 <mi_d+0x6b0>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
cmp    $0x1,%rcx
je     184e <mi_d+0x6de>
movslq 0x0(%rbp,%rdx,4),%rcx
movapd %xmm1,%xmm3
subsd  (%rax,%rcx,8),%xmm3
andpd  %xmm4,%xmm3
ucomisd %xmm2,%xmm3
jbe    18c3 <mi_d+0x753>
movsd  %xmm3,(%rdi,%rbx,8)
movapd %xmm3,%xmm2
movslq 0x4(%rbp,%rdx,4),%rcx
movapd %xmm1,%xmm3
subsd  (%rax,%rcx,8),%xmm3
andpd  %xmm4,%xmm3
ucomisd %xmm2,%xmm3
jbe    1890 <mi_d+0x720>
movsd  %xmm3,(%rdi,%rbx,8)
movapd %xmm3,%xmm2
jmp    1890 <mi_d+0x720>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0x8(%rsp)
mov    0x4(%rsp),%edx
jle    1660 <mi_d+0x4f0>
xor    %r14d,%r14d
jmp    1927 <mi_d+0x7b7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
cmp    0x10(%rsp),%r14
mov    0x108(%rsp),%r15
je     1660 <mi_d+0x4f0>
test   %r15d,%r15d
jle    1910 <mi_d+0x7a0>
mov    0x48(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    %rax,0xd0(%rsp)
xor    %r13d,%r13d
jmp    19f0 <mi_d+0x880>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%r13,8),%rdi
mov    0x50(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
mov    %r12d,%esi
movsd  0xc8(%rsp),%xmm0
mov    0x4(%rsp),%r15d
mov    %r15d,%edx
mov    0x80(%rsp),%rcx
mov    0xe0(%rsp),%r8
mov    0xf0(%rsp),%r9
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0x58(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
mov    %eax,(%rcx,%r13,4)
add    $0x1,%eax
mov    0x60(%rsp),%r12
mov    0x30(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    %r15d,%edx
cltq
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rdi,%r14,8),%xmm0
movsd  %xmm0,(%rdi,%r14,8)
movslq (%rbx,%r13,4),%rax
movsd  (%rcx,%rax,8),%xmm0
addsd  (%rsi,%r14,8),%xmm0
movsd  %xmm0,(%rsi,%r14,8)
add    $0x1,%r13
cmp    %r13,0x40(%rsp)
je     1910 <mi_d+0x7a0>
mov    0x78(%rsp),%r15
mov    (%r15,%r13,8),%rdi
mov    %r13d,%eax
and    $0x1,%eax
movsd  0x140(%rsp,%rax,8),%xmm0
mov    0xd0(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
mov    (%r12,%r13,8),%rcx
mov    0x38(%rsp),%rax
mov    (%rax,%r13,8),%r8
mov    0x68(%rsp),%rax
mov    (%rax,%r13,8),%r9
mov    0x70(%rsp),%r12
mov    %r12d,%esi
movsd  %xmm0,0xc8(%rsp)
mov    %rcx,0x80(%rsp)
mov    %r8,0xe0(%rsp)
mov    %r9,0xf0(%rsp)
mov    $0x2,%al
call   1070 <neiE1@plt>
mov    0x110(%rsp),%rcx
mov    (%rcx,%r14,8),%rbx
mov    %eax,(%rbx,%r13,4)
mov    0x28(%rsp),%rcx
mov    (%rcx,%r14,4),%ecx
cmp    %rcx,%r13
jne    1950 <mi_d+0x7e0>
mov    0x58(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
mov    %eax,(%rcx,%r13,4)
mov    0x60(%rsp),%r12
mov    0x30(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x4(%rsp),%edx
jmp    19b9 <mi_d+0x849>
cmpl   $0x0,0x8(%rsp)
movapd 0x150(%rsp),%xmm7
jle    1c49 <mi_d+0xad9>
lea    -0x1(%r15),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x30(%rsp),%rax
mov    0x98(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
cmpl   $0x1,0x8(%rsp)
jne    1ae8 <mi_d+0x978>
xor    %r9d,%r9d
jmp    1b9a <mi_d+0xa2a>
mov    0x10(%rsp),%r8
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
mulpd  %xmm4,%xmm3
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
mov    0x90(%rsp),%rsi
mov    0x100(%rsp),%rdi
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm4
divpd  %xmm2,%xmm4
movupd %xmm4,(%rbx,%rcx,8)
movupd 0x8(%rdx,%rcx,8),%xmm5
addpd  %xmm3,%xmm5
subpd  %xmm4,%xmm5
cvtpd2ps %xmm5,%xmm4
movupd (%rax,%rcx,8),%xmm5
divpd  %xmm2,%xmm5
movupd %xmm5,(%rax,%rcx,8)
movupd 0x8(%rdi,%rcx,8),%xmm6
addpd  %xmm3,%xmm6
subpd  %xmm5,%xmm6
cvtpd2ps %xmm6,%xmm5
unpcklps %xmm5,%xmm4
movupd %xmm4,(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1b40 <mi_d+0x9d0>
cmp    %r8,%r9
je     1c49 <mi_d+0xad9>
mov    0x18(%rsp),%rax
lea    (%rax,%r9,8),%rcx
mov    0x20(%rsp),%rdx
lea    (%rdx,%r9,8),%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%r9,8),%rsi
add    $0x4,%rsi
mov    0x10(%rsp),%rdi
sub    %r9,%rdi
mov    0x100(%rsp),%rbx
lea    (%rbx,%r9,8),%r8
add    $0x8,%r8
mov    0x30(%rsp),%rbx
lea    (%rbx,%r9,8),%rax
add    $0x8,%rax
xor    %ebx,%ebx
mulsd  %xmm1,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,8),%xmm1
divsd  %xmm7,%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
movsd  (%rax,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
subsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,-0x4(%rsi,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm1
divsd  %xmm7,%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
movsd  (%r8,%rbx,8),%xmm2
addsd  %xmm0,%xmm2
subsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%rsi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1bf0 <mi_d+0xa80>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0xb8(%rsp),%rbp
mov    0x118(%rsp),%r14
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1c70 <mi_d+0xb00>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
test   %r15d,%r15d
mov    0x68(%rsp),%r14
mov    0x38(%rsp),%rbp
jle    1cd5 <mi_d+0xb65>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1cb0 <mi_d+0xb40>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x48(%rsp),%r12
mov    0x58(%rsp),%r14
mov    0x110(%rsp),%r15
mov    0x10(%rsp),%rbp
jle    1d34 <mi_d+0xbc4>
xor    %ebx,%ebx
nopl   (%rax)
mov    (%r12,%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,%rbp
jne    1d10 <mi_d+0xba0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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