void mi_xnynKembed(double **x, int dim, int N, int K, double **xx, double **yy,
                   int **boxx, int *lisx, int *indx, int **boxy, int *lisy,
                   int *indy, double *psi, double *mi_cr) {
  int i, ik, k, *nx1, *ny1, *nx2, *ny2;
  double *xc, dy, dx;
  double *epsx, *epsy, *Eps;
  char *maxdim;
  double *dxy1, *dxy2;
  int *nn;
  int d;
  int BOX;
  int **box, *lis;
  int *ind;
  double epsilon;
  int inveps;
  double *phi;
  phi = (double *)malloc((K + 1) * sizeof(double));
  for (i = 1; i <= K; i++)
    phi[i] = psi[i] - 1 / ((double)(i));
  nn = (int *)malloc((K + 1) * sizeof(int));
  xc = (double *)malloc((2 * dim) * sizeof(double));
  dxy1 = (double *)malloc((K) * sizeof(double));
  dxy2 = (double *)malloc((K) * sizeof(double));
  nx1 = (int *)malloc((K) * sizeof(int));
  nx2 = (int *)malloc((K) * sizeof(int));
  ny1 = (int *)malloc((K) * sizeof(int));
  ny2 = (int *)malloc((K) * sizeof(int));
  epsx = (double *)malloc((K) * sizeof(double));
  epsy = (double *)malloc((K) * sizeof(double));
  Eps = (double *)malloc((K) * sizeof(double));
  maxdim = (char *)malloc((K) * sizeof(char));
  BOX = 1;
  while (0.5 * BOX * BOX * K < N)
    BOX *= 2;
  epsilon = 4.0 / BOX;
  inveps = BOX / 4;
  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));
  ind = (int *)malloc((N) * sizeof(int));
  make_box2ind(x, 2 * dim, N, 0, dim, BOX, inveps, ind, box, lis);
  for (ik = 0; ik < K; ik++) {
    dxy1[ik] = dxy2[ik] = 0.0;
  }
  for (i = 0; i < N; i++) {
    for (d = 0; d < 2 * dim; d++)
      xc[d] = x[d][ind[i]];
    neiK(x, 2 * dim, 0, dim, ind[i], BOX, epsilon, K, box, lis, nn);
    for (ik = 0; ik < K; ik++) {
      epsx[ik] = 0;
      for (d = 0; d < dim; d++)
        for (k = 1; k <= ik + 1; k++)
          if ((dx = fabs(xc[d] - x[d][nn[k]])) > epsx[ik])
            epsx[ik] = dx;
      epsy[ik] = 0;
      for (d = dim; d < 2 * dim; d++)
        for (k = 1; k <= ik + 1; k++)
          if ((dy = fabs(xc[d] - x[d][nn[k]])) > epsy[ik])
            epsy[ik] = dy;
    }
    neiEK(xx, indx[i], 0, dim - 1, dim, K, BOX, epsilon, epsx, boxx, lisx, nx2);
    neiEK(yy, indy[i], 0, dim - 1, dim, K, BOX, epsilon, epsy, boxy, lisy, ny2);
    for (ik = 0; ik < K; ik++) {
      maxdim[ik] = 0;
      if (epsx[ik] > epsy[ik]) {
        Eps[ik] = epsx[ik];
      } else {
        Eps[ik] = epsy[ik];
        maxdim[ik] = 1;
      }
    }
    neiEK(yy, indy[i], 0, dim - 1, dim, K, BOX, epsilon, Eps, boxy, lisy, ny1);
    neiEK(xx, indx[i], 0, dim - 1, dim, K, BOX, epsilon, Eps, boxx, lisx, nx1);
    for (ik = 0; ik < K; ik++) {
      if (maxdim[ik])
        dxy1[ik] += psi[nx1[ik] + 1] + psi[ny1[ik]];
      else
        dxy1[ik] += psi[nx1[ik]] + psi[ny1[ik] + 1];
      dxy2[ik] += psi[nx2[ik]] + psi[ny2[ik]];
    }
  }
  for (ik = 0; ik < K; ik++) {
    dxy1[ik] /= N;
    mi_cr[2 * ik] = psi[N] + psi[ik + 1] - dxy1[ik];
    dxy2[ik] /= N;
    mi_cr[2 * ik + 1] = psi[N] + phi[ik + 1] - dxy2[ik];
  }
  free(xc);
  free(nn);
  free(lis);
  for (i = 0; i < BOX; i++)
    free(box[i]);
  free(box);
  free(ind);
  free(phi);
  free(epsx);
  free(epsy);
  free(Eps);
  free(maxdim);
  free(nx1);
  free(nx2);
  free(ny1);
  free(ny2);
  free(dxy1);
  free(dxy2);
}


x86 assembly (clang, -O0):
<mi_xnynKembed>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x110,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     11ff <mi_xnynKembed+0xaf>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x3c(%rbp),%xmm2
movsd  0xe37(%rip),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b3 <mi_xnynKembed+0x63>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x0,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x1,-0xc0(%rbp)
cvtsi2sdl -0xc0(%rbp),%xmm0
ff
movsd  0xcfc(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0xc0(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1340 <mi_xnynKembed+0x1f0>
mov    -0xc0(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    12f4 <mi_xnynKembed+0x1a4>
cvtsi2sdl -0xc0(%rbp),%xmm1
ff
movsd  0xcb8(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xc0(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0xe4(%rbp)
movslq -0xc0(%rbp),%rdi
shl    $0x3,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc0(%rbp),%eax
jge    13cd <mi_xnynKembed+0x27d>
movslq -0xc0(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0xc8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    138e <mi_xnynKembed+0x23e>
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0xd8(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
shl    $0x1,%esi
mov    -0x20(%rbp),%edx
mov    -0x1c(%rbp),%r8d
mov    -0xc0(%rbp),%r9d
mov    -0xe4(%rbp),%ebx
mov    -0xd8(%rbp),%r11
mov    -0xc8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %ecx,%ecx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   1040 <make_box2ind@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    148a <mi_xnynKembed+0x33a>
mov    -0xb0(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    144a <mi_xnynKembed+0x2fa>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1a8a <mi_xnynKembed+0x93a>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1502 <mi_xnynKembed+0x3b2>
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xd8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    14a7 <mi_xnynKembed+0x357>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
shl    $0x1,%esi
mov    -0x1c(%rbp),%ecx
mov    -0xd8(%rbp),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    -0xc0(%rbp),%r9d
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x24(%rbp),%ebx
mov    -0xc8(%rbp),%r11
mov    -0xd0(%rbp),%r10
mov    -0xb8(%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,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1746 <mi_xnynKembed+0x5f6>
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1651 <mi_xnynKembed+0x501>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1638 <mi_xnynKembed+0x4e8>
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa2f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1625 <mi_xnynKembed+0x4d5>
movsd  -0x80(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    162a <mi_xnynKembed+0x4da>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15a6 <mi_xnynKembed+0x456>
jmp    163d <mi_xnynKembed+0x4ed>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1590 <mi_xnynKembed+0x440>
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1733 <mi_xnynKembed+0x5e3>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     171a <mi_xnynKembed+0x5ca>
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xbc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xb8(%rbp),%rcx
movslq -0x44(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x94d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1707 <mi_xnynKembed+0x5b7>
movsd  -0x78(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    170c <mi_xnynKembed+0x5bc>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1688 <mi_xnynKembed+0x538>
jmp    171f <mi_xnynKembed+0x5cf>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    166d <mi_xnynKembed+0x51d>
jmp    1738 <mi_xnynKembed+0x5e8>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1567 <mi_xnynKembed+0x417>
mov    -0x30(%rbp),%rdi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x24(%rbp),%r9d
mov    -0xc0(%rbp),%r14d
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rbx
mov    0x10(%rbp),%r11
mov    0x18(%rbp),%r10
mov    -0x60(%rbp),%rax
xor    %edx,%edx
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1060 <neiEK@plt>
mov    -0x38(%rbp),%rdi
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x24(%rbp),%r9d
mov    -0xc0(%rbp),%r14d
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x90(%rbp),%rbx
mov    0x28(%rbp),%r11
mov    0x30(%rbp),%r10
mov    -0x68(%rbp),%rax
xor    %edx,%edx
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1060 <neiEK@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    18b5 <mi_xnynKembed+0x765>
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1873 <mi_xnynKembed+0x723>
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18a2 <mi_xnynKembed+0x752>
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    18a7 <mi_xnynKembed+0x757>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    180d <mi_xnynKembed+0x6bd>
mov    -0x38(%rbp),%rdi
mov    0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x24(%rbp),%r9d
mov    -0xc0(%rbp),%r14d
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rbx
mov    0x28(%rbp),%r11
mov    0x30(%rbp),%r10
mov    -0x58(%rbp),%rax
xor    %edx,%edx
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1060 <neiEK@plt>
mov    -0x30(%rbp),%rdi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x24(%rbp),%r9d
mov    -0xc0(%rbp),%r14d
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rbx
mov    0x10(%rbp),%r11
mov    0x18(%rbp),%r10
mov    -0x50(%rbp),%rax
xor    %edx,%edx
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x1,%al
call   1060 <neiEK@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1a77 <mi_xnynKembed+0x927>
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     19e6 <mi_xnynKembed+0x896>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a2a <mi_xnynKembed+0x8da>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x60(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    197c <mi_xnynKembed+0x82c>
jmp    1a7c <mi_xnynKembed+0x92c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1491 <mi_xnynKembed+0x341>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1b6f <mi_xnynKembed+0xa1f>
cvtsi2sdl -0x20(%rbp),%xmm1
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x20(%rbp),%xmm1
mov    -0xb0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x40(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a91 <mi_xnynKembed+0x941>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc0(%rbp),%eax
jge    1bc8 <mi_xnynKembed+0xa78>
mov    -0xc8(%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    1b97 <mi_xnynKembed+0xa47>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%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    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
add    $0x110,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<mi_xnynKembed>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0xe8(%rsp)
mov    %ecx,%ebp
mov    %edx,0x18(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,%r13
mov    0x1c8(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x1c0(%rsp),%rbx
mov    0x1b8(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    0x1a0(%rsp),%r12
mov    0x198(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,0xd0(%rsp)
lea    0x1(%rbp),%r15d
movslq %r15d,%r14
lea    0x0(,%r14,8),%rdi
call   1080 <malloc@plt>
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    1332 <mi_xnynKembed+0x1d2>
mov    %r15d,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x2,%r8
jb     12fc <mi_xnynKembed+0x19c>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
lea    -0x2(%rdx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     200c <mi_xnynKembed+0xeac>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0x1db6(%rip),%xmm0
mov    $0x1,%edi
movapd 0x1db9(%rip),%xmm1
movdqa 0x1dc1(%rip),%xmm2
movdqa 0x1dc9(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rdi,8),%xmm4
cvtdq2pd %xmm0,%xmm5
movapd %xmm1,%xmm6
divpd  %xmm5,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,(%rax,%rdi,8)
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movupd 0x10(%rbx,%rdi,8),%xmm5
cvtdq2pd %xmm4,%xmm4
movapd %xmm1,%xmm6
divpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x10(%rax,%rdi,8)
paddd  %xmm3,%xmm0
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1280 <mi_xnynKembed+0x120>
cvtdq2pd %xmm0,%xmm0
test   $0x1,%bpl
je     12f0 <mi_xnynKembed+0x190>
movupd (%rbx,%rdi,8),%xmm1
movapd 0x1d6d(%rip),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdi,8)
cmp    %rdx,%r8
je     1332 <mi_xnynKembed+0x1d2>
or     $0x1,%r8
mov    %r8,%rdx
movsd  0x1d6c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
addsd  (%rbx,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1310 <mi_xnynKembed+0x1b0>
mov    %r12,0xe0(%rsp)
mov    %rbx,0xb0(%rsp)
mov    %rax,0xa0(%rsp)
shl    $0x2,%r14
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,%r12
mov    0x10(%rsp),%rax
add    %eax,%eax
mov    %eax,0x24(%rsp)
cltq
mov    %rax,0x150(%rsp)
lea    0x0(,%rax,8),%rdi
call   1080 <malloc@plt>
mov    %rax,0x90(%rsp)
movslq 0x8(%rsp),%rbp
lea    0x0(,%rbp,8),%r14
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,0x40(%rsp)
lea    0x0(,%rbp,4),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0xc0(%rsp)
mov    %r14,%rbx
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %r14,%rdi
call   1080 <malloc@plt>
mov    %rax,%r14
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %rbp,%rdi
call   1080 <malloc@plt>
mov    %rax,0x88(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rsp),%xmm0
cvtsi2sdl 0x18(%rsp),%xmm4
mov    $0x1,%eax
movsd  0x1c37(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
lea    (%rcx,%rcx,1),%eax
ucomisd %xmm3,%xmm4
ja     1450 <mi_xnynKembed+0x2f0>
movapd %xmm4,0x100(%rsp)
movsd  0x1bfd(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %ecx,%ebx
lea    0x0(,%rbx,8),%rdi
mov    %rcx,%rbp
call   1080 <malloc@plt>
mov    %rax,0x80(%rsp)
shl    $0x2,%rbx
mov    %rbx,0x60(%rsp)
cmp    $0x2,%ebp
mov    $0x1,%ebx
mov    %rbp,0x30(%rsp)
cmovae %ebp,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x60(%rsp),%rdi
call   1080 <malloc@plt>
mov    0x80(%rsp),%rcx
mov    %rax,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    14d0 <mi_xnynKembed+0x370>
mov    %rbx,0x118(%rsp)
mov    0x30(%rsp),%rax
shr    $0x2,%eax
mov    %rax,0x60(%rsp)
movslq 0x18(%rsp),%rax
mov    %rax,0x110(%rsp)
lea    0x0(,%rax,4),%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    %r13,%rdi
mov    0x24(%rsp),%esi
mov    0x18(%rsp),%edx
xor    %ecx,%ecx
mov    0x10(%rsp),%r8
mov    0x30(%rsp),%r9
xor    %eax,%eax
mov    %rbp,0xf0(%rsp)
push   %rbp
push   0x88(%rsp)
mov    %rbx,0x108(%rsp)
push   %rbx
push   0x78(%rsp)
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    0x8(%rsp),%r10
mov    %r10d,%ebx
test   %r10d,%r10d
jle    15a6 <mi_xnynKembed+0x446>
lea    0x0(,%rbx,8),%rbp
mov    0x40(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x48(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x8(%rsp),%r10
mov    0x18(%rsp),%esi
test   %esi,%esi
mov    0xb0(%rsp),%rbp
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%r9
movapd 0x100(%rsp),%xmm5
jle    1d5b <mi_xnynKembed+0xbfb>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x4(%rsp)
mov    0x24(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%edx
cmovge %ecx,%edx
movslq %eax,%rcx
mov    %rcx,0x148(%rsp)
mov    %esi,%ecx
mov    %rcx,0x140(%rsp)
mov    %eax,%eax
mov    %rax,0x60(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0x130(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0x138(%rsp)
and    $0x7ffffffc,%edx
mov    %rdx,0x128(%rsp)
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x120(%rsp)
xor    %ecx,%ecx
mov    %rbx,0x18(%rsp)
jmp    172d <mi_xnynKembed+0x5cd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x70(%rsp),%rax
mov    0x38(%rsp),%rcx
mov    (%rax,%rcx,4),%esi
sub    $0x8,%rsp
mov    0x80(%rsp),%rdi
xor    %edx,%edx
mov    0xc(%rsp),%ecx
mov    0x18(%rsp),%r8
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
push   0x60(%rsp)
push   %rbp
push   0x80(%rsp)
mov    0x70(%rsp),%rbx
push   %rbx
mov    0x58(%rsp),%rbp
push   %rbp
call   1070 <neiEK@plt>
add    $0x30,%rsp
mov    0xe0(%rsp),%rax
mov    0x38(%rsp),%rcx
mov    (%rax,%rcx,4),%esi
sub    $0x8,%rsp
mov    0xf0(%rsp),%rdi
xor    %edx,%edx
mov    0xc(%rsp),%ecx
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
push   0xb0(%rsp)
push   0xe8(%rsp)
push   0xe8(%rsp)
push   %rbx
push   %rbp
call   1070 <neiEK@plt>
mov    0x38(%rsp),%r10
add    $0x30,%rsp
mov    0xb0(%rsp),%rbp
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%r9
movapd 0x100(%rsp),%xmm5
mov    0x18(%rsp),%rbx
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
cmp    0x140(%rsp),%rcx
je     1d5b <mi_xnynKembed+0xbfb>
mov    0xf8(%rsp),%rax
mov    %rcx,0x38(%rsp)
movslq (%rax,%rcx,4),%r8
mov    0x10(%rsp),%rcx
test   %ecx,%ecx
mov    0x90(%rsp),%rbp
mov    0x30(%rsp),%r9
movsd  0x28(%rsp),%xmm0
mov    0x138(%rsp),%rbx
jle    1818 <mi_xnynKembed+0x6b8>
cmpq   $0x3,0x130(%rsp)
jae    1780 <mi_xnynKembed+0x620>
xor    %eax,%eax
jmp    17dd <mi_xnynKembed+0x67d>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
mov    0x128(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movsd  (%rdx,%r8,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
mov    0x8(%r13,%rax,8),%rdx
movsd  (%rdx,%r8,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
mov    0x10(%r13,%rax,8),%rdx
movsd  (%rdx,%r8,8),%xmm1
movsd  %xmm1,0x10(%rbp,%rax,8)
mov    0x18(%r13,%rax,8),%rdx
movsd  (%rdx,%r8,8),%xmm1
movsd  %xmm1,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1790 <mi_xnynKembed+0x630>
test   %rbx,%rbx
je     1818 <mi_xnynKembed+0x6b8>
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1800 <mi_xnynKembed+0x6a0>
mov    %r13,%rdi
mov    0x24(%rsp),%esi
xor    %edx,%edx
mov    $0x1,%al
push   %r12
push   0xf8(%rsp)
push   0x90(%rsp)
push   %r10
call   1060 <neiK@plt>
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%r9
add    $0x20,%rsp
test   %r9d,%r9d
mov    0xe8(%rsp),%rdi
movapd 0x1805(%rip),%xmm3
jle    1a60 <mi_xnynKembed+0x900>
mov    $0x1,%r11d
xor    %ecx,%ecx
jmp    1882 <mi_xnynKembed+0x722>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
mov    %r10,%rcx
cmp    0x18(%rsp),%r10
je     1a60 <mi_xnynKembed+0x900>
mov    %r11,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
lea    0x1(%rcx),%r10
movq   $0x0,(%r15,%rcx,8)
test   %r8d,%r8d
jle    1970 <mi_xnynKembed+0x810>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    18c7 <mi_xnynKembed+0x767>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    0x60(%rsp),%rbx
mov    0x90(%rsp),%rbp
je     1970 <mi_xnynKembed+0x810>
movsd  0x0(%rbp,%rbx,8),%xmm1
mov    0x0(%r13,%rbx,8),%rax
mov    $0x1,%ebp
test   %rcx,%rcx
jne    1922 <mi_xnynKembed+0x7c2>
test   $0x1,%r10b
je     18b0 <mi_xnynKembed+0x750>
movslq (%r12,%rbp,4),%rdx
subsd  (%rax,%rdx,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
jbe    18b0 <mi_xnynKembed+0x750>
movsd  %xmm1,(%r15,%rcx,8)
movapd %xmm1,%xmm0
jmp    18b0 <mi_xnynKembed+0x750>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
je     18dc <mi_xnynKembed+0x77c>
movslq (%r12,%rbp,4),%rdx
movapd %xmm1,%xmm2
subsd  (%rax,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm0,%xmm2
jbe    1943 <mi_xnynKembed+0x7e3>
movsd  %xmm2,(%r15,%rcx,8)
movapd %xmm2,%xmm0
movslq 0x4(%r12,%rbp,4),%rdx
movapd %xmm1,%xmm2
subsd  (%rax,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm0,%xmm2
jbe    1910 <mi_xnynKembed+0x7b0>
movsd  %xmm2,(%r15,%rcx,8)
movapd %xmm2,%xmm0
jmp    1910 <mi_xnynKembed+0x7b0>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%r14,%rcx,8)
cmp    %r8d,0x24(%rsp)
jle    1870 <mi_xnynKembed+0x710>
xorpd  %xmm0,%xmm0
mov    0x148(%rsp),%rbx
jmp    19ba <mi_xnynKembed+0x85a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    0x150(%rsp),%rbx
mov    0x90(%rsp),%rbp
je     1870 <mi_xnynKembed+0x710>
movsd  0x0(%rbp,%rbx,8),%xmm1
mov    0x0(%r13,%rbx,8),%rax
mov    $0x1,%ebp
test   %rcx,%rcx
jne    1a12 <mi_xnynKembed+0x8b2>
test   $0x1,%r10b
je     19a0 <mi_xnynKembed+0x840>
movslq (%r12,%rbp,4),%rdx
subsd  (%rax,%rdx,8),%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
jbe    19a0 <mi_xnynKembed+0x840>
movsd  %xmm1,(%r14,%rcx,8)
movapd %xmm1,%xmm0
jmp    19a0 <mi_xnynKembed+0x840>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsi,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
je     19cf <mi_xnynKembed+0x86f>
movslq (%r12,%rbp,4),%rdx
movapd %xmm1,%xmm2
subsd  (%rax,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm0,%xmm2
jbe    1a33 <mi_xnynKembed+0x8d3>
movsd  %xmm2,(%r14,%rcx,8)
movapd %xmm2,%xmm0
movslq 0x4(%r12,%rbp,4),%rdx
movapd %xmm1,%xmm2
subsd  (%rax,%rdx,8),%xmm2
andpd  %xmm3,%xmm2
ucomisd %xmm0,%xmm2
jbe    1a00 <mi_xnynKembed+0x8a0>
movsd  %xmm2,(%r14,%rcx,8)
movapd %xmm2,%xmm0
jmp    1a00 <mi_xnynKembed+0x8a0>
nopw   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rbx
mov    0xe0(%rsp),%rax
mov    (%rax,%rbx,4),%esi
sub    $0x8,%rsp
xor    %edx,%edx
mov    0xc(%rsp),%ecx
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
push   0xd0(%rsp)
push   0xe8(%rsp)
push   0xe8(%rsp)
push   %r15
push   0x58(%rsp)
mov    %r8,%rbp
call   1070 <neiEK@plt>
add    $0x30,%rsp
mov    0x70(%rsp),%rax
mov    (%rax,%rbx,4),%esi
sub    $0x8,%rsp
mov    0x80(%rsp),%rdi
xor    %edx,%edx
mov    0xc(%rsp),%ecx
mov    %ebp,%r8d
mov    0x10(%rsp),%r9
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
push   0xc8(%rsp)
mov    0xc8(%rsp),%rbp
push   %rbp
push   0x80(%rsp)
push   %r14
push   0x58(%rsp)
call   1070 <neiEK@plt>
mov    0x38(%rsp),%r9
add    $0x30,%rsp
test   %r9d,%r9d
jle    1650 <mi_xnynKembed+0x4f0>
xor    %eax,%eax
cmp    $0x1,%r9d
jne    1cc0 <mi_xnynKembed+0xb60>
mov    0x78(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x70(%rsp),%rsi
mov    0xb8(%rsp),%r11
mov    0x68(%rsp),%r10
mov    0x50(%rsp),%rbp
mov    0x88(%rsp),%rdx
movsd  0x28(%rsp),%xmm0
mov    0x4(%rsp),%ecx
testb  $0x1,0x18(%rsp)
je     1b71 <mi_xnynKembed+0xa11>
movb   $0x0,(%rdx,%rax,1)
movsd  (%r15,%rax,8),%xmm2
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm1,%xmm2
ja     1b6b <mi_xnynKembed+0xa0b>
movb   $0x1,(%rdx,%rax,1)
movapd %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rax,8)
mov    0x38(%rsp),%rax
mov    (%rsi,%rax,4),%esi
sub    $0x8,%rsp
xor    %edx,%edx
mov    $0x1,%al
push   0x60(%rsp)
push   %r11
push   %r10
push   %rbp
mov    0x58(%rsp),%rbx
push   %rbx
mov    %ecx,%ebp
call   1070 <neiEK@plt>
add    $0x30,%rsp
mov    0xe0(%rsp),%rax
mov    0x38(%rsp),%rcx
mov    (%rax,%rcx,4),%esi
sub    $0x8,%rsp
mov    0xf0(%rsp),%rdi
xor    %edx,%edx
mov    %ebp,%ecx
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
mov    0xb0(%rsp),%rbp
push   %rbp
push   0xe8(%rsp)
push   0xe8(%rsp)
push   0x70(%rsp)
push   %rbx
call   1070 <neiEK@plt>
mov    0x38(%rsp),%r10
mov    %rbp,%r8
add    $0x30,%rsp
test   %r10d,%r10d
mov    0xb0(%rsp),%rbp
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%r9
mov    0xc8(%rsp),%rdi
mov    0xc0(%rsp),%rsi
movapd 0x100(%rsp),%xmm5
mov    0x18(%rsp),%rbx
jle    1716 <mi_xnynKembed+0x5b6>
xor    %eax,%eax
jmp    1c96 <mi_xnynKembed+0xb36>
nopw   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rdx
mov    (%rdx,%rax,4),%edx
add    $0x1,%edx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
movslq %edx,%rcx
addsd  0x0(%rbp,%rcx,8),%xmm0
addsd  (%r11,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movslq (%rdi,%rax,4),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
movslq (%rsi,%rax,4),%rcx
addsd  0x0(%rbp,%rcx,8),%xmm0
addsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
je     1716 <mi_xnynKembed+0x5b6>
mov    0x88(%rsp),%rcx
cmpb   $0x0,(%rcx,%rax,1)
mov    (%r8,%rax,4),%ecx
je     1c40 <mi_xnynKembed+0xae0>
add    $0x1,%ecx
mov    0x58(%rsp),%rdx
mov    (%rdx,%rax,4),%edx
jmp    1c4b <mi_xnynKembed+0xaeb>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x78(%rsp),%rdi
mov    0x10(%rsp),%r8
mov    0x70(%rsp),%rsi
mov    0xb8(%rsp),%r11
mov    0x68(%rsp),%r10
mov    0x50(%rsp),%rbp
mov    0x88(%rsp),%rdx
movsd  0x28(%rsp),%xmm0
mov    0x4(%rsp),%ecx
mov    0x120(%rsp),%rbx
jmp    1d13 <mi_xnynKembed+0xbb3>
nopl   (%rax)
movsd  %xmm2,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
je     1b46 <mi_xnynKembed+0x9e6>
movb   $0x0,(%rdx,%rax,1)
movsd  (%r15,%rax,8),%xmm2
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm1,%xmm2
ja     1d31 <mi_xnynKembed+0xbd1>
movb   $0x1,(%rdx,%rax,1)
movapd %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rax,8)
movb   $0x0,0x1(%rdx,%rax,1)
movsd  0x8(%r15,%rax,8),%xmm2
movsd  0x8(%r14,%rax,8),%xmm1
ucomisd %xmm1,%xmm2
ja     1d00 <mi_xnynKembed+0xba0>
movb   $0x1,0x1(%rdx,%rax,1)
movapd %xmm1,%xmm2
jmp    1d00 <mi_xnynKembed+0xba0>
test   %r10d,%r10d
jle    1e1e <mi_xnynKembed+0xcbe>
mov    0x110(%rsp),%rsi
lea    0x0(,%rsi,8),%r8
add    %rbp,%r8
cmp    $0x1,%r10d
jne    1f11 <mi_xnynKembed+0xdb1>
xor    %ecx,%ecx
lea    (%r9,%rcx,8),%rdx
lea    (%r11,%rcx,8),%rsi
mov    %rcx,%rax
shl    $0x4,%rax
mov    0x98(%rsp),%rdi
add    %rax,%rdi
add    $0x8,%rdi
sub    %rcx,%rbx
mov    0xa0(%rsp),%rax
lea    (%rax,%rcx,8),%r9
add    $0x8,%r9
lea    0x8(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,1),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rsi,%rax,1)
movsd  (%r8),%xmm1
addsd  (%rcx,%rax,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rdi,%rax,2)
movsd  (%rdx,%rax,1),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,(%rdx,%rax,1)
movsd  (%r8),%xmm1
addsd  (%r9,%rax,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,2)
add    $0x8,%rax
add    $0xffffffffffffffff,%rbx
jne    1dd0 <mi_xnynKembed+0xc70>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xf0(%rsp),%rdi
call   1030 <free@plt>
xor    %ebp,%ebp
mov    0x118(%rsp),%rbx
mov    0x80(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1e60 <mi_xnynKembed+0xd00>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xf8(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0xc8(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    %rbx,%rcx
shl    $0x4,%rcx
mov    0x98(%rsp),%rax
add    %rax,%rcx
lea    0x8(%rbp),%r10
lea    0x8(,%rbx,8),%rdx
add    %rbp,%rdx
lea    0x8(,%rsi,8),%rsi
add    %rbp,%rsi
cmp    %rax,%rdx
seta   %dil
cmp    %rcx,%r10
setb   %dl
cmp    %rax,%rsi
seta   %al
cmp    %rcx,%r8
setb   %sil
xor    %ecx,%ecx
test   %dl,%dil
jne    1d83 <mi_xnynKembed+0xc23>
and    %sil,%al
jne    1d83 <mi_xnynKembed+0xc23>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %edx,%edx
mov    0x98(%rsp),%rsi
mov    0xa0(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movupd (%r11,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r11,%rdx,8)
movsd  (%r8),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%rbp,%rdx,8),%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm1,%xmm3
movupd (%r9,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r9,%rdx,8)
movsd  (%r8),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%rax,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
subpd  %xmm1,%xmm4
movapd %xmm3,%xmm1
unpcklpd %xmm4,%xmm1
movhlps %xmm3,%xmm4
movups %xmm4,0x10(%rsi)
movupd %xmm1,(%rsi)
add    $0x2,%rdx
add    $0x20,%rsi
cmp    %rdx,%rcx
jne    1f90 <mi_xnynKembed+0xe30>
cmp    %rbx,%rcx
jne    1d83 <mi_xnynKembed+0xc23>
jmp    1e1e <mi_xnynKembed+0xcbe>
movapd 0xfec(%rip),%xmm0
mov    $0x1,%edi
test   $0x1,%bpl
jne    12d6 <mi_xnynKembed+0x176>
jmp    12f0 <mi_xnynKembed+0x190>

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

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