void mi_xnynK(double **x, int dimx, int dimy, int N, int K, double *psi,
              double *scal, double *mi_cr) {
  int i, ik, k, *nx1, *ny1, *nx2, *ny2;
  double *xc, dy, dx;
  double *epsx, *epsy, *Eps;
  double *dxy1, *dxy2;
  double **xx, **yy;
  ;
  double scalx, scaly;
  int *nn;
  int d;
  int BOX, BOX1;
  int **box, **boxy, **boxx, *lis;
  int *lisy, *lisx;
  int *boxx1, *boxy1;
  int *lisy1, *lisx1;
  int *mxi, *myi;
  int *ind, *indx, *indy;
  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((dimx + dimy) * 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));
  BOX = 1;
  while (0.5 * BOX * BOX * K < N)
    BOX *= 2;
  epsilon = 4.0 / BOX;
  inveps = BOX / 4;
  BOX1 = N - 5;
  if (dimx > 1) {
    xx = (double **)malloc((dimx) * sizeof(double *));
    for (d = 0; d < dimx; d++)
      xx[d] = (double *)malloc((N) * sizeof(double));
    boxx = (int **)malloc((BOX) * sizeof(int *));
    for (i = 0; i < BOX; i++)
      boxx[i] = (int *)malloc((BOX) * sizeof(int));
    lisx = (int *)malloc((N) * sizeof(int));
  } else {
    boxx1 = (int *)malloc((BOX1 + 1) * sizeof(int));
    lisx1 = (int *)malloc((N) * sizeof(int));
    mxi = (int *)malloc((BOX1 + 1) * sizeof(int));
  }
  if (dimy > 1) {
    yy = (double **)malloc((dimy) * sizeof(double *));
    for (d = 0; d < dimy; d++)
      yy[d] = (double *)malloc((N) * sizeof(double));
    boxy = (int **)malloc((BOX) * sizeof(int *));
    for (i = 0; i < BOX; i++)
      boxy[i] = (int *)malloc((BOX) * sizeof(int));
    lisy = (int *)malloc((N) * sizeof(int));
  } else {
    boxy1 = (int *)malloc((BOX1 + 1) * sizeof(int));
    lisy1 = (int *)malloc((N) * sizeof(int));
    myi = (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));
  ind = (int *)malloc((N) * sizeof(int));
  indx = (int *)malloc((N) * sizeof(int));
  indy = (int *)malloc((N) * sizeof(int));
  if (dimx > 1)
    for (d = 0; d < dimx; d++)
      memcpy(xx[d], x[d], N * sizeof(double));
  if (dimy > 1)
    for (d = 0; d < dimy; d++)
      memcpy(yy[d], x[d + dimx], N * sizeof(double));
  make_box2ind(x, dimx + dimy, N, 0, dimx, BOX, inveps, ind, box, lis);
  if (dimx == 1) {
    scalx = scal[0];
    make_box1(x[0], N, scalx, BOX1, boxx1, lisx1, mxi);
  } else
    make_box2ind(xx, dimx, N, 0, dimx - 1, BOX, inveps, indx, boxx, lisx);
  if (dimy == 1) {
    scaly = scal[dimx];
    make_box1(x[dimx], N, scaly, BOX1, boxy1, lisy1, myi);
  } else
    make_box2ind(yy, dimy, N, 0, dimy - 1, BOX, inveps, indy, boxy, lisy);
  for (ik = 0; ik < K; ik++) {
    dxy1[ik] = dxy2[ik] = 0.0;
  }
  for (i = 0; i < N; i++) {
    for (d = 0; d < dimx + dimy; d++)
      xc[d] = x[d][ind[i]];
    neiK(x, dimx + dimy, 0, dimx, ind[i], BOX, epsilon, K, box, lis, nn);
    for (ik = 0; ik < K; ik++) {
      epsx[ik] = 0;
      for (d = 0; d < dimx; 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 = dimx; d < dimx + dimy; d++)
        for (k = 1; k <= ik + 1; k++)
          if ((dy = fabs(xc[d] - x[d][nn[k]])) > epsy[ik])
            epsy[ik] = dy;
      if (dimx > 1)
        nx2[ik] = neiE(xx, indx[i], 0, dimx - 1, dimx, BOX, epsilon, epsx[ik],
                       boxx, lisx);
      else
        nx2[ik] = neiE1(x[0], ind[i], scalx, BOX1, epsx[ik], boxx1, lisx1, mxi);
      if (dimy > 1)
        ny2[ik] = neiE(yy, indy[i], 0, dimy - 1, dimy, BOX, epsilon, epsy[ik],
                       boxy, lisy);
      else
        ny2[ik] =
            neiE1(x[dimx], ind[i], scaly, BOX1, epsy[ik], boxy1, lisy1, myi);
      if (epsx[ik] > epsy[ik]) {
        Eps[ik] = epsx[ik];
        nx1[ik] = nx2[ik];
        if (dimy > 1)
          ny1[ik] = neiE(yy, indy[i], 0, dimy - 1, dimy, BOX, epsilon, Eps[ik],
                         boxy, lisy);
        else
          ny1[ik] =
              neiE1(x[dimx], ind[i], scaly, BOX1, Eps[ik], boxy1, lisy1, myi);
        dxy1[ik] += psi[nx1[ik]] + psi[ny1[ik] + 1];
      } else {
        Eps[ik] = epsy[ik];
        ny1[ik] = ny2[ik];
        if (dimx > 1)
          nx1[ik] = neiE(xx, indx[i], 0, dimx - 1, dimx, BOX, epsilon, Eps[ik],
                         boxx, lisx);
        else
          nx1[ik] =
              neiE1(x[0], ind[i], scalx, BOX1, Eps[ik], boxx1, lisx1, mxi);
        dxy1[ik] += psi[nx1[ik] + 1] + psi[ny1[ik]];
      }
      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(indx);
  free(indy);
  if (dimx == 1) {
    free(mxi);
    free(boxx1);
    free(lisx1);
  } else {
    for (i = 0; i < BOX; i++)
      free(boxx[i]);
    free(boxx);
    free(lisx);
    for (d = 0; d < dimx; d++)
      free(xx[d]);
    free(xx);
  }
  if (dimy == 1) {
    free(myi);
    free(boxy1);
    free(lisy1);
  } else {
    for (i = 0; i < BOX; i++)
      free(boxy[i]);
    free(boxy);
    free(lisy);
    for (d = 0; d < dimy; d++)
      free(yy[d]);
    free(yy);
  }
  free(phi);
  free(epsx);
  free(epsy);
  free(Eps);
  free(nx1);
  free(nx2);
  free(ny1);
  free(ny2);
  free(dxy1);
  free(dxy2);
}


x86 assembly (clang, -O0):
<mi_xnynK>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x178,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x160(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1215 <mi_xnynK+0x95>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm2
movsd  0x1e21(%rip),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x160(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c9 <mi_xnynK+0x49>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x20(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x1,-0xc8(%rbp)
cvtsi2sdl -0xc8(%rbp),%xmm0
ff
movsd  0x1d00(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0xc8(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    133c <mi_xnynK+0x1bc>
mov    -0xc8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    12f0 <mi_xnynK+0x170>
cvtsi2sdl -0xc8(%rbp),%xmm1
ff
movsd  0x1cbc(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xc8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x154(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0xcc(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    145b <mi_xnynK+0x2db>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e5 <mi_xnynK+0x265>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xa0(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    13a0 <mi_xnynK+0x220>
movslq -0xc8(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    1442 <mi_xnynK+0x2c2>
movslq -0xc8(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xe8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1403 <mi_xnynK+0x283>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x100(%rbp)
jmp    14a7 <mi_xnynK+0x327>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x108(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x120(%rbp)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x128(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    158a <mi_xnynK+0x40a>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1514 <mi_xnynK+0x394>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    14cf <mi_xnynK+0x34f>
movslq -0xc8(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    1571 <mi_xnynK+0x3f1>
movslq -0xc8(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xe0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1532 <mi_xnynK+0x3b2>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf8(%rbp)
jmp    15d6 <mi_xnynK+0x456>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x110(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x118(%rbp)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x130(%rbp)
movslq -0xc8(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    1633 <mi_xnynK+0x4b3>
movslq -0xc8(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xd8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15f4 <mi_xnynK+0x474>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x138(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x140(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x148(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    16ed <mi_xnynK+0x56d>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16e8 <mi_xnynK+0x568>
mov    -0xa0(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x3,%rdx
call   1080 <memcpy@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1697 <mi_xnynK+0x517>
jmp    16ed <mi_xnynK+0x56d>
cmpl   $0x1,-0x18(%rbp)
jle    175c <mi_xnynK+0x5dc>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1757 <mi_xnynK+0x5d7>
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0xc4(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x3,%rdx
call   1080 <memcpy@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1701 <mi_xnynK+0x581>
jmp    175c <mi_xnynK+0x5dc>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    -0xc8(%rbp),%r9d
mov    -0x154(%rbp),%ebx
mov    -0x138(%rbp),%r11
mov    -0xd8(%rbp),%r10
mov    -0xf0(%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>
cmpl   $0x1,-0x14(%rbp)
jne    17fd <mi_xnynK+0x67d>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x108(%rbp),%rcx
mov    -0x120(%rbp),%r8
mov    -0x128(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    184f <mi_xnynK+0x6cf>
mov    -0xa0(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xc8(%rbp),%r9d
mov    -0x154(%rbp),%ebx
mov    -0x140(%rbp),%r11
mov    -0xe8(%rbp),%r10
mov    -0x100(%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>
cmpl   $0x1,-0x18(%rbp)
jne    18ac <mi_xnynK+0x72c>
mov    0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x110(%rbp),%rcx
mov    -0x118(%rbp),%r8
mov    -0x130(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    18fe <mi_xnynK+0x77e>
mov    -0xa8(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xc8(%rbp),%r9d
mov    -0x154(%rbp),%ebx
mov    -0x148(%rbp),%r11
mov    -0xe0(%rbp),%r10
mov    -0xf8(%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,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1945 <mi_xnynK+0x7c5>
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1905 <mi_xnynK+0x785>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    20a5 <mi_xnynK+0xf25>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    19bd <mi_xnynK+0x83d>
mov    -0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x138(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1962 <mi_xnynK+0x7e2>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    -0x138(%rbp),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    -0xc8(%rbp),%r9d
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x20(%rbp),%ebx
mov    -0xd8(%rbp),%r11
mov    -0xf0(%rbp),%r10
mov    -0xc0(%rbp),%rax
xor    %edx,%edx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x1,%al
call   1060 <neiK@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    2092 <mi_xnynK+0xf12>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b03 <mi_xnynK+0x983>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1aea <mi_xnynK+0x96a>
mov    -0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x1577(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1ad7 <mi_xnynK+0x957>
movsd  -0x70(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1adc <mi_xnynK+0x95c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a5e <mi_xnynK+0x8de>
jmp    1aef <mi_xnynK+0x96f>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1a48 <mi_xnynK+0x8c8>
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1bdc <mi_xnynK+0xa5c>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1bc3 <mi_xnynK+0xa43>
mov    -0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc0(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x149e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1bb0 <mi_xnynK+0xa30>
movsd  -0x68(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1bb5 <mi_xnynK+0xa35>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b37 <mi_xnynK+0x9b7>
jmp    1bc8 <mi_xnynK+0xa48>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1b1c <mi_xnynK+0x99c>
cmpl   $0x1,-0x14(%rbp)
jle    1c53 <mi_xnynK+0xad3>
mov    -0xa0(%rbp),%rdi
mov    -0x140(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0xc8(%rbp),%r9d
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm1
mov    -0xe8(%rbp),%r10
mov    -0x100(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,%edx
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1cac <mi_xnynK+0xb2c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x138(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rcx
mov    -0x120(%rbp),%r8
mov    -0x128(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,%edx
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x18(%rbp)
jle    1d23 <mi_xnynK+0xba3>
mov    -0xa8(%rbp),%rdi
mov    -0x148(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0xc8(%rbp),%r9d
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm1
mov    -0xe0(%rbp),%r10
mov    -0xf8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,%edx
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1d81 <mi_xnynK+0xc01>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x138(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rcx
mov    -0x118(%rbp),%r8
mov    -0x130(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,%edx
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1ef8 <mi_xnynK+0xd78>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x18(%rbp)
jle    1e4e <mi_xnynK+0xcce>
mov    -0xa8(%rbp),%rdi
mov    -0x148(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0xc8(%rbp),%r9d
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm1
mov    -0xe0(%rbp),%r10
mov    -0xf8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,%edx
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1eaf <mi_xnynK+0xd2f>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x138(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x110(%rbp),%rcx
mov    -0x118(%rbp),%r8
mov    -0x130(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,%edx
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2045 <mi_xnynK+0xec5>
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x14(%rbp)
jle    1fa5 <mi_xnynK+0xe25>
mov    -0xa0(%rbp),%rdi
mov    -0x140(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0xc8(%rbp),%r9d
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rdx
movsd  (%rax,%rdx,8),%xmm1
mov    -0xe8(%rbp),%r10
mov    -0x100(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    2001 <mi_xnynK+0xe81>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x138(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xcc(%rbp),%edx
mov    -0x88(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x108(%rbp),%rcx
mov    -0x120(%rbp),%r8
mov    -0x128(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a22 <mi_xnynK+0x8a2>
jmp    2097 <mi_xnynK+0xf17>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    194c <mi_xnynK+0x7cc>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    218a <mi_xnynK+0x100a>
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x1c(%rbp),%xmm1
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    20ac <mi_xnynK+0xf2c>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    21e3 <mi_xnynK+0x1063>
mov    -0xd8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    21b2 <mi_xnynK+0x1032>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x138(%rbp),%rdi
call   1030 <free@plt>
mov    -0x140(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x14(%rbp)
jne    2246 <mi_xnynK+0x10c6>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
mov    -0x120(%rbp),%rdi
call   1030 <free@plt>
jmp    22e6 <mi_xnynK+0x1166>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    227e <mi_xnynK+0x10fe>
mov    -0xe8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    224d <mi_xnynK+0x10cd>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    22da <mi_xnynK+0x115a>
mov    -0xa0(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    22a0 <mi_xnynK+0x1120>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x18(%rbp)
jne    2319 <mi_xnynK+0x1199>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
jmp    23b9 <mi_xnynK+0x1239>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    2351 <mi_xnynK+0x11d1>
mov    -0xe0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2320 <mi_xnynK+0x11a0>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    23ad <mi_xnynK+0x122d>
mov    -0xa8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    2373 <mi_xnynK+0x11f3>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
add    $0x178,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mi_xnynK>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,%rbp
mov    %r8d,%ebx
mov    %ecx,%r13d
mov    %rdx,0x20(%rsp)
mov    %rsi,(%rsp)
mov    %rdi,%r12
mov    0x1e8(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x1(%rbx),%r15d
movslq %r15d,%r14
lea    0x0(,%r14,8),%rdi
call   10b0 <malloc@plt>
mov    %rbx,0xc8(%rsp)
test   %ebx,%ebx
jle    1313 <mi_xnynK+0x183>
mov    %r15d,%ebx
lea    -0x1(%rbx),%rcx
mov    $0x1,%edx
cmp    $0x2,%rcx
jb     12e6 <mi_xnynK+0x156>
mov    %rcx,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2488 <mi_xnynK+0x12f8>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0x1dc6(%rip),%xmm0
xor    %esi,%esi
movapd 0x1dcc(%rip),%xmm1
movdqa 0x1dd4(%rip),%xmm2
movdqa 0x1ddc(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%rbp,%rsi,8),%xmm4
cvtdq2pd %xmm0,%xmm5
movapd %xmm1,%xmm6
divpd  %xmm5,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,0x8(%rax,%rsi,8)
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movupd 0x18(%rbp,%rsi,8),%xmm5
cvtdq2pd %xmm4,%xmm4
movapd %xmm1,%xmm6
divpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x18(%rax,%rsi,8)
add    $0x4,%rsi
paddd  %xmm3,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    1260 <mi_xnynK+0xd0>
test   $0x1,%dl
je     12da <mi_xnynK+0x14a>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd 0x0(%rbp,%rsi,1),%xmm1
cvtdq2pd %xmm0,%xmm0
movapd 0x1d73(%rip),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rsi,1)
cmp    %r8,%rcx
je     1313 <mi_xnynK+0x183>
or     $0x1,%rcx
mov    %rcx,%rdx
movsd  0x1d72(%rip),%xmm0
xchg   %ax,%ax
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    12f0 <mi_xnynK+0x160>
mov    %rbp,0x140(%rsp)
mov    %rax,0x128(%rsp)
shl    $0x2,%r14
mov    %r14,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    0x20(%rsp),%rax
mov    (%rsp),%rcx
add    %ecx,%eax
mov    %eax,0x44(%rsp)
cltq
mov    %rax,0x88(%rsp)
lea    0x0(,%rax,8),%rdi
call   10b0 <malloc@plt>
mov    %rax,0x68(%rsp)
mov    0xc8(%rsp),%rbx
movslq %ebx,%r15
shl    $0x3,%r15
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x118(%rsp)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x148(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
xorps  %xmm3,%xmm3
cvtsi2sd %r13d,%xmm3
mov    $0x1,%eax
movsd  0x1cc0(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
mov    %eax,%ebx
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    (%rbx,%rbx,1),%eax
ucomisd %xmm2,%xmm3
ja     13b0 <mi_xnynK+0x220>
movsd  %xmm4,0xa0(%rsp)
movapd %xmm3,0x160(%rsp)
movslq %r13d,%rbp
mov    (%rsp),%rax
cmp    $0x2,%eax
mov    %rbx,0x10(%rsp)
mov    %rbp,0x60(%rsp)
mov    %r13,0xb0(%rsp)
jl     14c6 <mi_xnynK+0x336>
mov    %eax,%r13d
lea    0x0(,%r13,8),%rdi
call   10b0 <malloc@plt>
mov    %rax,%rbx
lea    0x0(,%rbp,8),%r15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1430 <mi_xnynK+0x2a0>
mov    %rbx,0x30(%rsp)
mov    0x10(%rsp),%rbp
mov    %ebp,%r13d
lea    0x0(,%r13,8),%rdi
call   10b0 <malloc@plt>
mov    %rax,%r15
shl    $0x2,%r13
cmp    $0x2,%ebp
mov    $0x1,%ebx
cmovae %ebp,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
call   10b0 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1480 <mi_xnynK+0x2f0>
mov    %r15,0x100(%rsp)
mov    0x60(%rsp),%rbp
lea    0x0(,%rbp,4),%rdi
call   10b0 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rbx
mov    0xb0(%rsp),%r13
jmp    1500 <mi_xnynK+0x370>
lea    -0x10(,%rbp,4),%r15
ff
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xd8(%rsp)
lea    0x0(,%rbp,4),%rdi
call   10b0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xd0(%rsp)
movsd  0x1b68(%rip),%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x20(%rsp),%rax
cmp    $0x2,%eax
jl     15d9 <mi_xnynK+0x449>
mov    %eax,%r13d
lea    0x0(,%r13,8),%rdi
call   10b0 <malloc@plt>
mov    %rax,%rbx
lea    0x0(,%rbp,8),%r15
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1540 <mi_xnynK+0x3b0>
mov    %rbx,0x18(%rsp)
mov    0x10(%rsp),%rbx
mov    %ebx,%r15d
lea    0x0(,%r15,8),%rdi
mov    %rdi,0x38(%rsp)
call   10b0 <malloc@plt>
mov    %rax,%r13
shl    $0x2,%r15
cmp    $0x2,%ebx
mov    $0x1,%ebp
cmovae %ebx,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1590 <mi_xnynK+0x400>
mov    %rbp,0x78(%rsp)
mov    0x60(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   10b0 <malloc@plt>
mov    %rax,0xf0(%rsp)
mov    0x10(%rsp),%rbx
mov    0x38(%rsp),%rdi
mov    0xb0(%rsp),%rcx
jmp    1635 <mi_xnynK+0x4a5>
lea    -0x10(,%rbp,4),%r15
ff
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xf8(%rsp)
lea    0x0(,%rbp,4),%rdi
call   10b0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0xe8(%rsp)
mov    %ebx,%r15d
lea    0x0(,%r15,8),%rdi
shl    $0x2,%r15
cmp    $0x2,%ebx
mov    $0x1,%eax
cmovae %ebx,%eax
mov    %rax,0x78(%rsp)
mov    %r13,%rcx
mov    %r13,0x80(%rsp)
movsd  0x50(%rsp),%xmm0
divsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
shr    $0x2,%ebx
mov    %rbx,0x38(%rsp)
lea    -0x5(%rcx),%eax
mov    %eax,0xc(%rsp)
call   10b0 <malloc@plt>
mov    %rax,%r13
xor    %ebx,%ebx
mov    0x78(%rsp),%rbp
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1670 <mi_xnynK+0x4e0>
mov    %r13,0x138(%rsp)
mov    0x60(%rsp),%rax
lea    0x0(,%rax,4),%r15
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x130(%rsp)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x110(%rsp)
mov    %r15,%rdi
call   10b0 <malloc@plt>
mov    %rax,0x108(%rsp)
mov    (%rsp),%r8
cmp    $0x2,%r8d
mov    %r13,0x48(%rsp)
jl     1777 <mi_xnynK+0x5e7>
mov    0x60(%rsp),%rax
lea    0x0(,%rax,8),%r15
mov    %r8d,%eax
mov    %rax,0xa0(%rsp)
lea    0x0(,%rax,8),%r13
and    $0xfffffffffffffff0,%r13
xor    %ebp,%ebp
mov    0x30(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rbp,1),%rdi
mov    (%r12,%rbp,1),%rsi
mov    %r15,%rdx
call   1090 <memcpy@plt>
mov    0x8(%rbx,%rbp,1),%rdi
mov    0x8(%r12,%rbp,1),%rsi
mov    %r15,%rdx
call   1090 <memcpy@plt>
add    $0x10,%rbp
cmp    %rbp,%r13
jne    1720 <mi_xnynK+0x590>
testb  $0x1,0xa0(%rsp)
01
mov    (%rsp),%r8
mov    0x48(%rsp),%r13
je     1777 <mi_xnynK+0x5e7>
mov    0x30(%rsp),%rax
mov    (%rax,%rbp,1),%rdi
mov    (%r12,%rbp,1),%rsi
mov    %r15,%rdx
call   1090 <memcpy@plt>
mov    (%rsp),%r8
cmpl   $0x2,0x20(%rsp)
jl     181a <mi_xnynK+0x68a>
mov    0x60(%rsp),%rax
lea    0x0(,%rax,8),%rdx
movslq %r8d,%rax
mov    0x20(%rsp),%ecx
lea    (%r12,%rax,8),%rbp
mov    %rcx,0x70(%rsp)
lea    0x0(,%rcx,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0xa0(%rsp)
xor    %ebx,%ebx
mov    0x18(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbx,1),%rdi
mov    0x0(%rbp,%rbx,1),%rsi
mov    %rdx,%r13
call   1090 <memcpy@plt>
mov    0x8(%r15,%rbx,1),%rdi
mov    0x8(%rbp,%rbx,1),%rsi
mov    %r13,%rdx
call   1090 <memcpy@plt>
mov    %r13,%rdx
add    $0x10,%rbx
cmp    %rbx,0xa0(%rsp)
jne    17c0 <mi_xnynK+0x630>
testb  $0x1,0x70(%rsp)
mov    (%rsp),%r8
mov    0x48(%rsp),%r13
je     181a <mi_xnynK+0x68a>
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,1),%rdi
mov    (%rbx,%rbp,1),%rsi
call   1090 <memcpy@plt>
mov    (%rsp),%r8
mov    %r12,%rdi
mov    0x44(%rsp),%esi
mov    0xb0(%rsp),%rbp
mov    %ebp,%edx
xor    %ecx,%ecx
mov    0x10(%rsp),%rbx
mov    %ebx,%r9d
xor    %eax,%eax
push   0x130(%rsp)
push   0x140(%rsp)
push   %r13
mov    0x50(%rsp),%r15
push   %r15
call   1040 <make_box2ind@plt>
mov    0x20(%rsp),%rsi
add    $0x20,%rsp
cmp    $0x1,%esi
mov    0xf0(%rsp),%r13
jne    18a3 <mi_xnynK+0x713>
mov    0x58(%rsp),%rax
movsd  (%rax),%xmm0
mov    (%r12),%rdi
mov    %ebp,%esi
movsd  %xmm0,0x178(%rsp)
mov    0xc(%rsp),%edx
mov    0xd8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xd0(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    18d5 <mi_xnynK+0x745>
lea    -0x1(%rsi),%r8d
mov    0x30(%rsp),%rdi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xe0(%rsp)
push   0x108(%rsp)
push   0x120(%rsp)
push   %r15
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    0xc8(%rsp),%r15
mov    0x80(%rsp),%rbp
mov    0x20(%rsp),%rsi
cmp    $0x1,%esi
jne    1931 <mi_xnynK+0x7a1>
movslq (%rsp),%rax
mov    0x58(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    (%r12,%rax,8),%rdi
mov    0xb0(%rsp),%rsi
movsd  %xmm0,0x70(%rsp)
mov    0xc(%rsp),%edx
mov    0xf8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0xe8(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1962 <mi_xnynK+0x7d2>
lea    -0x1(%rsi),%r8d
mov    0x18(%rsp),%rdi
mov    0xb0(%rsp),%rdx
xor    %ecx,%ecx
mov    0x10(%rsp),%r9
xor    %eax,%eax
push   %r13
push   %rbp
push   0x118(%rsp)
push   0x50(%rsp)
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    %r15d,%ebp
test   %r15d,%r15d
jle    1996 <mi_xnynK+0x806>
lea    0x0(,%rbp,8),%rbx
mov    0x148(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1060 <memset@plt>
mov    0x118(%rsp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1060 <memset@plt>
mov    %rbp,0x180(%rsp)
mov    0xb0(%rsp),%rcx
test   %ecx,%ecx
mov    (%rsp),%r11
movapd 0x160(%rsp),%xmm1
mov    0x68(%rsp),%r10
jle    20c9 <mi_xnynK+0xf39>
movslq %r11d,%rdi
lea    -0x1(%r11),%eax
mov    %eax,0x9c(%rsp)
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%ebp
mov    %ecx,%eax
mov    %rax,0x1a0(%rsp)
mov    0x44(%rsp),%eax
mov    %eax,%ecx
mov    %r11d,%r13d
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x190(%rsp)
mov    %eax,%ebx
and    $0x3,%ebx
and    $0xfffffffc,%eax
mov    %rax,0x188(%rsp)
xor    %ecx,%ecx
mov    %rdi,0x150(%rsp)
mov    %ebp,0x15c(%rsp)
mov    %rbx,0x198(%rsp)
jmp    1a53 <mi_xnynK+0x8c3>
mov    0x90(%rsp),%rcx
add    $0x1,%rcx
cmp    0x1a0(%rsp),%rcx
mov    0xc8(%rsp),%r15
movapd 0x160(%rsp),%xmm1
mov    0x198(%rsp),%rbx
je     20c9 <mi_xnynK+0xf39>
mov    0x48(%rsp),%rax
mov    %rcx,0x90(%rsp)
movslq (%rax,%rcx,4),%r8
cmpl   $0x0,0x44(%rsp)
mov    0x10(%rsp),%r9
jle    1b18 <mi_xnynK+0x988>
cmpq   $0x3,0x190(%rsp)
jae    1a90 <mi_xnynK+0x900>
xor    %eax,%eax
jmp    1aef <mi_xnynK+0x95f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
mov    0x188(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
mov    0x8(%r12,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x8(%r10,%rax,8)
mov    0x10(%r12,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x10(%r10,%rax,8)
mov    0x18(%r12,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x18(%r10,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1aa0 <mi_xnynK+0x910>
test   %rbx,%rbx
je     1b18 <mi_xnynK+0x988>
lea    (%r10,%rax,8),%rcx
lea    (%r12,%rax,8),%rax
xor    %edx,%edx
xchg   %ax,%ax
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1b00 <mi_xnynK+0x970>
mov    %r12,%rdi
mov    0x44(%rsp),%esi
xor    %edx,%edx
mov    %r11d,%ecx
movsd  0x50(%rsp),%xmm0
mov    $0x1,%al
push   %r14
push   0x138(%rsp)
push   0x148(%rsp)
push   %r15
call   1070 <neiK@plt>
movapd 0x1505(%rip),%xmm3
movapd 0x14fd(%rip),%xmm2
mov    0x88(%rsp),%r10
mov    0x20(%rsp),%r11
add    $0x20,%rsp
test   %r15d,%r15d
mov    0x88(%rsp),%rbp
jle    1a20 <mi_xnynK+0x890>
mov    $0x1,%r8d
xor    %r15d,%r15d
jmp    1c5a <mi_xnynK+0xaca>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,0x2c(%rsp)
mov    (%r12),%rdi
mov    0x48(%rsp),%rax
mov    (%rax,%rbp,4),%esi
movsd  0x178(%rsp),%xmm0
mov    0xc(%rsp),%edx
mov    0xd8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xd0(%rsp),%r9
mov    $0x2,%al
call   10a0 <neiE1@plt>
mov    0x2c(%rsp),%ecx
mov    (%rsp),%r11
mov    0x88(%rsp),%rbp
mov    0x68(%rsp),%r10
movapd 0x146a(%rip),%xmm2
movapd 0x1462(%rip),%xmm3
mov    0x38(%rsp),%r8
mov    0x58(%rsp),%rsi
cltq
movslq %ecx,%rcx
mov    0x140(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  0x8(%rdx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x118(%rsp),%rax
addsd  (%rax,%r15,8),%xmm1
movsd  %xmm1,(%rax,%r15,8)
movsd  (%rdx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
mov    0x148(%rsp),%rax
addsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,(%rax,%r15,8)
add    $0x1,%r8
mov    %rbx,%r15
cmp    0x180(%rsp),%rbx
je     1a20 <mi_xnynK+0x890>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
lea    0x1(%r15),%rbx
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
test   %r11d,%r11d
jle    1d10 <mi_xnynK+0xb80>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    1c99 <mi_xnynK+0xb09>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r13,%rcx
je     1d10 <mi_xnynK+0xb80>
movsd  (%r10,%rcx,8),%xmm0
mov    (%r12,%rcx,8),%rdx
mov    $0x1,%esi
test   %r15,%r15
je     1ced <mi_xnynK+0xb5d>
nopl   (%rax)
movslq (%r14,%rsi,4),%rdi
movapd %xmm0,%xmm5
subsd  (%rdx,%rdi,8),%xmm5
andpd  %xmm3,%xmm5
maxsd  %xmm1,%xmm5
movslq 0x4(%r14,%rsi,4),%rdi
movapd %xmm0,%xmm1
subsd  (%rdx,%rdi,8),%xmm1
andpd  %xmm3,%xmm1
maxsd  %xmm5,%xmm1
lea    (%rax,%rsi,1),%rdi
add    $0x2,%rdi
add    $0x2,%rsi
cmp    $0x1,%rdi
jne    1cb0 <mi_xnynK+0xb20>
test   $0x1,%bl
je     1c90 <mi_xnynK+0xb00>
movslq (%r14,%rsi,4),%rsi
subsd  (%rdx,%rsi,8),%xmm0
andpd  %xmm2,%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
jmp    1c90 <mi_xnynK+0xb00>
nopl   0x0(%rax)
cmpl   $0x0,0x20(%rsp)
jle    1db0 <mi_xnynK+0xc20>
xorpd  %xmm4,%xmm4
mov    0x150(%rsp),%rcx
jmp    1d39 <mi_xnynK+0xba9>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %rbp,%rcx
jge    1db0 <mi_xnynK+0xc20>
movsd  (%r10,%rcx,8),%xmm0
mov    (%r12,%rcx,8),%rdx
mov    $0x1,%esi
test   %r15,%r15
je     1d8d <mi_xnynK+0xbfd>
nopl   (%rax)
movslq (%r14,%rsi,4),%rdi
movapd %xmm0,%xmm5
subsd  (%rdx,%rdi,8),%xmm5
andpd  %xmm3,%xmm5
maxsd  %xmm4,%xmm5
movslq 0x4(%r14,%rsi,4),%rdi
movapd %xmm0,%xmm4
subsd  (%rdx,%rdi,8),%xmm4
andpd  %xmm3,%xmm4
maxsd  %xmm5,%xmm4
lea    (%rax,%rsi,1),%rdi
add    $0x2,%rdi
add    $0x2,%rsi
cmp    $0x1,%rdi
jne    1d50 <mi_xnynK+0xbc0>
test   $0x1,%bl
je     1d30 <mi_xnynK+0xba0>
movslq (%r14,%rsi,4),%rsi
subsd  (%rdx,%rsi,8),%xmm0
andpd  %xmm2,%xmm0
maxsd  %xmm4,%xmm0
movapd %xmm0,%xmm4
jmp    1d30 <mi_xnynK+0xba0>
nopl   0x0(%rax)
movapd %xmm4,0xa0(%rsp)
cmp    $0x2,%r11d
mov    %r8,0x38(%rsp)
movapd %xmm1,0xb0(%rsp)
jl     1e20 <mi_xnynK+0xc90>
mov    0x110(%rsp),%rax
mov    0x90(%rsp),%rbp
mov    (%rax,%rbp,4),%esi
mov    0x30(%rsp),%rdi
xor    %edx,%edx
mov    0x9c(%rsp),%ecx
mov    %r11d,%r8d
mov    0x10(%rsp),%r9
movsd  0x50(%rsp),%xmm0
mov    $0x2,%al
push   0xe0(%rsp)
push   0x108(%rsp)
call   1080 <neiE@plt>
movaps 0xb0(%rsp),%xmm1
add    $0x10,%rsp
jmp    1e65 <mi_xnynK+0xcd5>
nop
mov    (%r12),%rdi
mov    0x48(%rsp),%rax
mov    0x90(%rsp),%rbp
mov    (%rax,%rbp,4),%esi
movsd  0x178(%rsp),%xmm0
mov    0xc(%rsp),%edx
mov    0xd8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xd0(%rsp),%r9
mov    $0x2,%al
call   10a0 <neiE1@plt>
movaps 0xa0(%rsp),%xmm1
movsd  0x70(%rsp),%xmm0
cltq
mov    0x20(%rsp),%r8
cmp    $0x2,%r8d
mov    %rax,0x58(%rsp)
jl     1f40 <mi_xnynK+0xdb0>
mov    0x108(%rsp),%rax
mov    (%rax,%rbp,4),%esi
mov    0x18(%rsp),%rdi
xor    %edx,%edx
mov    0x15c(%rsp),%ebp
mov    %ebp,%ecx
mov    0x10(%rsp),%r9
movsd  0x50(%rsp),%xmm0
mov    $0x2,%al
push   0xf0(%rsp)
push   0x88(%rsp)
call   1080 <neiE@plt>
movapd 0xb0(%rsp),%xmm1
add    $0x10,%rsp
mov    %eax,%ecx
movapd 0xb0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    2050 <mi_xnynK+0xec0>
mov    0x90(%rsp),%rax
mov    0x108(%rsp),%rdx
mov    (%rdx,%rax,4),%esi
mov    %ecx,0x2c(%rsp)
mov    0x18(%rsp),%rdi
xor    %edx,%edx
mov    %ebp,%ecx
mov    0x20(%rsp),%r8
mov    0x10(%rsp),%r9
movsd  0x50(%rsp),%xmm0
movapd %xmm2,%xmm1
mov    $0x2,%al
push   0xf0(%rsp)
push   0x88(%rsp)
call   1080 <neiE@plt>
mov    0x3c(%rsp),%esi
add    $0x10,%rsp
jmp    1fde <mi_xnynK+0xe4e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x150(%rsp),%rax
mov    (%r12,%rax,8),%rdi
mov    0x48(%rsp),%rax
mov    (%rax,%rbp,4),%esi
movsd  %xmm0,0x70(%rsp)
mov    0xc(%rsp),%edx
mov    0xf8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0xe8(%rsp),%r9
mov    $0x2,%al
call   10a0 <neiE1@plt>
movapd 0xa0(%rsp),%xmm1
mov    %eax,%ecx
movapd 0xb0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    2070 <mi_xnynK+0xee0>
mov    %ecx,0x2c(%rsp)
mov    0x150(%rsp),%rax
mov    (%r12,%rax,8),%rdi
mov    0x48(%rsp),%rax
mov    (%rax,%rbp,4),%esi
movsd  0x70(%rsp),%xmm0
mov    0xc(%rsp),%edx
movapd %xmm2,%xmm1
mov    0xf8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0xe8(%rsp),%r9
mov    $0x2,%al
call   10a0 <neiE1@plt>
mov    0x2c(%rsp),%esi
mov    (%rsp),%r11
mov    0x88(%rsp),%rbp
mov    0x68(%rsp),%r10
movapd 0x1059(%rip),%xmm2
movapd 0x1051(%rip),%xmm3
mov    0x38(%rsp),%r8
mov    0x58(%rsp),%rdx
mov    0x140(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
cltq
movsd  0x8(%rcx,%rax,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x118(%rsp),%rax
addsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,(%rax,%r15,8)
movslq %esi,%rax
movsd  (%rcx,%rax,8),%xmm0
jmp    1c2d <mi_xnynK+0xa9d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%r8
movsd  0x50(%rsp),%xmm0
mov    0x90(%rsp),%rbp
jmp    207a <mi_xnynK+0xeea>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%r8
movsd  0x50(%rsp),%xmm0
mov    0x10(%rsp),%r9
cmp    $0x2,%r8d
jl     1b90 <mi_xnynK+0xa00>
mov    0x110(%rsp),%rax
mov    (%rax,%rbp,4),%esi
mov    %ecx,%ebp
mov    0x30(%rsp),%rdi
xor    %edx,%edx
mov    0x9c(%rsp),%ecx
mov    $0x2,%al
push   0xe0(%rsp)
push   0x108(%rsp)
call   1080 <neiE@plt>
mov    %ebp,%ecx
mov    0x10(%rsp),%r11
add    $0x10,%rsp
jmp    1bd1 <mi_xnynK+0xa41>
test   %r15d,%r15d
mov    0x118(%rsp),%r12
mov    0x148(%rsp),%rax
mov    %r15,%rbx
mov    %rax,%r15
mov    0x140(%rsp),%r11
mov    0x180(%rsp),%rcx
jle    21ae <mi_xnynK+0x101e>
mov    0x60(%rsp),%rdi
lea    (%r11,%rdi,8),%r13
cmp    $0x1,%ebx
jne    2389 <mi_xnynK+0x11f9>
xor    %ebx,%ebx
lea    (%r15,%rbx,8),%rdx
lea    (%r12,%rbx,8),%rsi
mov    %rbx,%rdi
shl    $0x4,%rdi
mov    0x120(%rsp),%rbp
add    %rbp,%rdi
add    $0x8,%rdi
sub    %rbx,%rcx
mov    0x128(%rsp),%rbp
lea    0x8(%rbp,%rbx,8),%rbp
lea    (%r11,%rbx,8),%rax
add    $0x8,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rsi,%rbx,1),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi,%rbx,1)
movsd  0x0(%r13),%xmm1
addsd  (%rax,%rbx,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rdi,%rbx,2)
movsd  (%rdx,%rbx,1),%xmm0
divsd  0x160(%rsp),%xmm0
movsd  %xmm0,(%rdx,%rbx,1)
movsd  0x0(%r13),%xmm1
addsd  0x0(%rbp,%rbx,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rbx,2)
movapd 0x160(%rsp),%xmm1
add    $0x8,%rbx
add    $0xffffffffffffffff,%rcx
jne    2150 <mi_xnynK+0xfc0>
mov    %r10,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x130(%rsp),%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0x78(%rsp),%rbp
mov    0x138(%rsp),%r14
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    21e0 <mi_xnynK+0x1050>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x110(%rsp),%rdi
call   1030 <free@plt>
mov    0x108(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x1,(%rsp)
mov    0x30(%rsp),%r13
mov    0x100(%rsp),%rbp
jne    224d <mi_xnynK+0x10bd>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
call   1030 <free@plt>
jmp    22b3 <mi_xnynK+0x1123>
xor    %ebx,%ebx
mov    0x78(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    2260 <mi_xnynK+0x10d0>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    (%rsp),%rax
test   %eax,%eax
jle    22b3 <mi_xnynK+0x1123>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    22a0 <mi_xnynK+0x1110>
mov    %r13,%rdi
call   1030 <free@plt>
cmpl   $0x1,0x20(%rsp)
mov    0x80(%rsp),%r14
mov    0xf8(%rsp),%rbx
mov    0xe8(%rsp),%rdi
jne    22ee <mi_xnynK+0x115e>
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%r13
jmp    2353 <mi_xnynK+0x11c3>
xor    %ebx,%ebx
mov    0x18(%rsp),%r13
mov    0x78(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    2300 <mi_xnynK+0x1170>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0xf0(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rax
test   %eax,%eax
jle    2353 <mi_xnynK+0x11c3>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2340 <mi_xnynK+0x11b0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x128(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    %rcx,%rax
shl    $0x4,%rax
mov    0x120(%rsp),%rbp
add    %rbp,%rax
lea    0x8(%r11),%rdx
lea    (%r11,%rcx,8),%rsi
add    $0x8,%rsi
lea    (%r11,%rdi,8),%rdi
add    $0x8,%rdi
cmp    %rbp,%rsi
seta   %r8b
cmp    %rax,%rdx
setb   %r9b
cmp    %rbp,%rdi
seta   %dl
cmp    %rax,%r13
setb   %sil
xor    %ebx,%ebx
test   %r9b,%r8b
jne    210c <mi_xnynK+0xf7c>
and    %sil,%dl
jne    210c <mi_xnynK+0xf7c>
mov    %ecx,%ebx
and    $0xfffffffe,%ebx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
xor    %edx,%edx
mov    0x120(%rsp),%rsi
mov    0x128(%rsp),%rdi
nopl   (%rax)
movupd (%r12,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rdx,8)
movsd  0x0(%r13),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%r11,%rdx,8),%xmm3
addpd  %xmm2,%xmm3
subpd  %xmm1,%xmm3
movupd (%r15,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r15,%rdx,8)
movsd  0x0(%r13),%xmm2
unpcklpd %xmm2,%xmm2
movupd 0x8(%rdi,%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,%rbx
jne    2400 <mi_xnynK+0x1270>
cmp    %rcx,%rbx
movapd 0x160(%rsp),%xmm1
jne    210c <mi_xnynK+0xf7c>
jmp    21ae <mi_xnynK+0x101e>
movdqa 0xb70(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%dl
jne    12b3 <mi_xnynK+0x123>
jmp    12da <mi_xnynK+0x14a>

LLVM IR (-O0):
define void @mi_xnynK(double** %0, i32 %1, i32 %2, i32 %3, i32 %4, double* %5, double* %6, double* %7) {
%9 = alloca double**
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca double*
%25 = alloca double
%26 = alloca double
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double**
%33 = alloca double**
%34 = alloca double
%35 = alloca double
%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 i32*
%45 = alloca i32*
%46 = alloca i32*
%47 = alloca i32*
%48 = alloca i32*
%49 = alloca i32*
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca i32*
%53 = alloca i32*
%54 = alloca i32*
%55 = alloca double
%56 = alloca i32
%57 = alloca double*
store double** %0, double*** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store double* %5, double** %14
store double* %6, double** %15
store double* %7, double** %16
%58 = load i32, i32* %13
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = mul i64 %60, 8
%62 = call i8* @malloc(i64 %61)
%63 = bitcast i8* %62 to double*
store double* %63, double** %57
store i32 1, i32* %17
br label %64
64: ; preds = %82, %8
%65 = load i32, i32* %17
%66 = load i32, i32* %13
%67 = icmp sle i32 %65, %66
br i1 %67, label %68, label %85
68: ; preds = %64
%69 = load double*, double** %14
%70 = load i32, i32* %17
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %69, i64 %71
%73 = load double, double* %72
%74 = load i32, i32* %17
%75 = sitofp i32 %74 to double
%76 = fdiv double 1.000000e+00, %75
%77 = fsub double %73, %76
%78 = load double*, double** %57
%79 = load i32, i32* %17
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
store double %77, double* %81
br label %82
82: ; preds = %68
%83 = load i32, i32* %17
%84 = add nsw i32 %83, 1
store i32 %84, i32* %17
br label %64
85: ; preds = %64
%86 = load i32, i32* %13
%87 = add nsw i32 %86, 1
%88 = sext i32 %87 to i64
%89 = mul i64 %88, 4
%90 = call i8* @malloc(i64 %89)
%91 = bitcast i8* %90 to i32*
store i32* %91, i32** %36
%92 = load i32, i32* %10
%93 = load i32, i32* %11
%94 = add nsw i32 %92, %93
%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** %24
%99 = load i32, i32* %13
%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** %30
%104 = load i32, i32* %13
%105 = sext i32 %104 to i64
%106 = mul i64 %105, 8
%107 = call i8* @malloc(i64 %106)
%108 = bitcast i8* %107 to double*
store double* %108, double** %31
%109 = load i32, i32* %13
%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** %20
%114 = load i32, i32* %13
%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** %22
%119 = load i32, i32* %13
%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** %21
%124 = load i32, i32* %13
%125 = sext i32 %124 to i64
%126 = mul i64 %125, 4
%127 = call i8* @malloc(i64 %126)
%128 = bitcast i8* %127 to i32*
store i32* %128, i32** %23
%129 = load i32, i32* %13
%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** %27
%134 = load i32, i32* %13
%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** %28
%139 = load i32, i32* %13
%140 = sext i32 %139 to i64
%141 = mul i64 %140, 8
%142 = call i8* @malloc(i64 %141)
%143 = bitcast i8* %142 to double*
store double* %143, double** %29
store i32 1, i32* %38
br label %144
144: ; preds = %157, %85
%145 = load i32, i32* %38
%146 = sitofp i32 %145 to double
%147 = fmul double 5.000000e-01, %146
%148 = load i32, i32* %38
%149 = sitofp i32 %148 to double
%150 = fmul double %147, %149
%151 = load i32, i32* %13
%152 = sitofp i32 %151 to double
%153 = fmul double %150, %152
%154 = load i32, i32* %12
%155 = sitofp i32 %154 to double
%156 = fcmp olt double %153, %155
br i1 %156, label %157, label %160
157: ; preds = %144
%158 = load i32, i32* %38
%159 = mul nsw i32 %158, 2
store i32 %159, i32* %38
br label %144
160: ; preds = %144
%161 = load i32, i32* %38
%162 = sitofp i32 %161 to double
%163 = fdiv double 4.000000e+00, %162
store double %163, double* %55
%164 = load i32, i32* %38
%165 = sdiv i32 %164, 4
store i32 %165, i32* %56
%166 = load i32, i32* %12
%167 = sub nsw i32 %166, 5
store i32 %167, i32* %39
%168 = load i32, i32* %10
%169 = icmp sgt i32 %168, 1
br i1 %169, label %170, label %222
170: ; preds = %160
%171 = load i32, i32* %10
%172 = sext i32 %171 to i64
%173 = mul i64 %172, 8
%174 = call i8* @malloc(i64 %173)
%175 = bitcast i8* %174 to double**
store double** %175, double*** %32
store i32 0, i32* %37
br label %176
176: ; preds = %190, %170
%177 = load i32, i32* %37
%178 = load i32, i32* %10
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %193
180: ; preds = %176
%181 = load i32, i32* %12
%182 = sext i32 %181 to i64
%183 = mul i64 %182, 8
%184 = call i8* @malloc(i64 %183)
%185 = bitcast i8* %184 to double*
%186 = load double**, double*** %32
%187 = load i32, i32* %37
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double*, double** %186, i64 %188
store double* %185, double** %189
br label %190
190: ; preds = %180
%191 = load i32, i32* %37
%192 = add nsw i32 %191, 1
store i32 %192, i32* %37
br label %176
193: ; preds = %176
%194 = load i32, i32* %38
%195 = sext i32 %194 to i64
%196 = mul i64 %195, 8
%197 = call i8* @malloc(i64 %196)
%198 = bitcast i8* %197 to i32**
store i32** %198, i32*** %42
store i32 0, i32* %17
br label %199
199: ; preds = %213, %193
%200 = load i32, i32* %17
%201 = load i32, i32* %38
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %216
203: ; preds = %199
%204 = load i32, i32* %38
%205 = sext i32 %204 to i64
%206 = mul i64 %205, 4
%207 = call i8* @malloc(i64 %206)
%208 = bitcast i8* %207 to i32*
%209 = load i32**, i32*** %42
%210 = load i32, i32* %17
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32*, i32** %209, i64 %211
store i32* %208, i32** %212
br label %213
213: ; preds = %203
%214 = load i32, i32* %17
%215 = add nsw i32 %214, 1
store i32 %215, i32* %17
br label %199
216: ; preds = %199
%217 = load i32, i32* %12
%218 = sext i32 %217 to i64
%219 = mul i64 %218, 4
%220 = call i8* @malloc(i64 %219)
%221 = bitcast i8* %220 to i32*
store i32* %221, i32** %45
br label %240
222: ; preds = %160
%223 = load i32, i32* %39
%224 = add nsw i32 %223, 1
%225 = sext i32 %224 to i64
%226 = mul i64 %225, 4
%227 = call i8* @malloc(i64 %226)
%228 = bitcast i8* %227 to i32*
store i32* %228, i32** %46
%229 = load i32, i32* %12
%230 = sext i32 %229 to i64
%231 = mul i64 %230, 4
%232 = call i8* @malloc(i64 %231)
%233 = bitcast i8* %232 to i32*
store i32* %233, i32** %49
%234 = load i32, i32* %39
%235 = add nsw i32 %234, 1
%236 = sext i32 %235 to i64
%237 = mul i64 %236, 4
%238 = call i8* @malloc(i64 %237)
%239 = bitcast i8* %238 to i32*
store i32* %239, i32** %50
br label %240
240: ; preds = %222, %216
%241 = load i32, i32* %11
%242 = icmp sgt i32 %241, 1
br i1 %242, label %243, label %295
243: ; preds = %240
%244 = load i32, i32* %11
%245 = sext i32 %244 to i64
%246 = mul i64 %245, 8
%247 = call i8* @malloc(i64 %246)
%248 = bitcast i8* %247 to double**
store double** %248, double*** %33
store i32 0, i32* %37
br label %249
249: ; preds = %263, %243
%250 = load i32, i32* %37
%251 = load i32, i32* %11
%252 = icmp slt i32 %250, %251
br i1 %252, label %253, label %266
253: ; preds = %249
%254 = load i32, i32* %12
%255 = sext i32 %254 to i64
%256 = mul i64 %255, 8
%257 = call i8* @malloc(i64 %256)
%258 = bitcast i8* %257 to double*
%259 = load double**, double*** %33
%260 = load i32, i32* %37
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double*, double** %259, i64 %261
store double* %258, double** %262
br label %263
263: ; preds = %253
%264 = load i32, i32* %37
%265 = add nsw i32 %264, 1
store i32 %265, i32* %37
br label %249
266: ; preds = %249
%267 = load i32, i32* %38
%268 = sext i32 %267 to i64
%269 = mul i64 %268, 8
%270 = call i8* @malloc(i64 %269)
%271 = bitcast i8* %270 to i32**
store i32** %271, i32*** %41
store i32 0, i32* %17
br label %272
272: ; preds = %286, %266
%273 = load i32, i32* %17
%274 = load i32, i32* %38
%275 = icmp slt i32 %273, %274
br i1 %275, label %276, label %289
276: ; preds = %272
%277 = load i32, i32* %38
%278 = sext i32 %277 to i64
%279 = mul i64 %278, 4
%280 = call i8* @malloc(i64 %279)
%281 = bitcast i8* %280 to i32*
%282 = load i32**, i32*** %41
%283 = load i32, i32* %17
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32*, i32** %282, i64 %284
store i32* %281, i32** %285
br label %286
286: ; preds = %276
%287 = load i32, i32* %17
%288 = add nsw i32 %287, 1
store i32 %288, i32* %17
br label %272
289: ; preds = %272
%290 = load i32, i32* %12
%291 = sext i32 %290 to i64
%292 = mul i64 %291, 4
%293 = call i8* @malloc(i64 %292)
%294 = bitcast i8* %293 to i32*
store i32* %294, i32** %44
br label %313
295: ; preds = %240
%296 = load i32, i32* %39
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = mul i64 %298, 4
%300 = call i8* @malloc(i64 %299)
%301 = bitcast i8* %300 to i32*
store i32* %301, i32** %47
%302 = load i32, i32* %12
%303 = sext i32 %302 to i64
%304 = mul i64 %303, 4
%305 = call i8* @malloc(i64 %304)
%306 = bitcast i8* %305 to i32*
store i32* %306, i32** %48
%307 = load i32, i32* %39
%308 = add nsw i32 %307, 1
%309 = sext i32 %308 to i64
%310 = mul i64 %309, 4
%311 = call i8* @malloc(i64 %310)
%312 = bitcast i8* %311 to i32*
store i32* %312, i32** %51
br label %313
313: ; preds = %295, %289
%314 = load i32, i32* %38
%315 = sext i32 %314 to i64
%316 = mul i64 %315, 8
%317 = call i8* @malloc(i64 %316)
%318 = bitcast i8* %317 to i32**
store i32** %318, i32*** %40
store i32 0, i32* %17
br label %319
319: ; preds = %333, %313
%320 = load i32, i32* %17
%321 = load i32, i32* %38
%322 = icmp slt i32 %320, %321
br i1 %322, label %323, label %336
323: ; preds = %319
%324 = load i32, i32* %38
%325 = sext i32 %324 to i64
%326 = mul i64 %325, 4
%327 = call i8* @malloc(i64 %326)
%328 = bitcast i8* %327 to i32*
%329 = load i32**, i32*** %40
%330 = load i32, i32* %17
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32*, i32** %329, i64 %331
store i32* %328, i32** %332
br label %333
333: ; preds = %323
%334 = load i32, i32* %17
%335 = add nsw i32 %334, 1
store i32 %335, i32* %17
br label %319
336: ; preds = %319
%337 = load i32, i32* %12
%338 = sext i32 %337 to i64
%339 = mul i64 %338, 4
%340 = call i8* @malloc(i64 %339)
%341 = bitcast i8* %340 to i32*
store i32* %341, i32** %43
%342 = load i32, i32* %12
%343 = sext i32 %342 to i64
%344 = mul i64 %343, 4
%345 = call i8* @malloc(i64 %344)
%346 = bitcast i8* %345 to i32*
store i32* %346, i32** %52
%347 = load i32, i32* %12
%348 = sext i32 %347 to i64
%349 = mul i64 %348, 4
%350 = call i8* @malloc(i64 %349)
%351 = bitcast i8* %350 to i32*
store i32* %351, i32** %53
%352 = load i32, i32* %12
%353 = sext i32 %352 to i64
%354 = mul i64 %353, 4
%355 = call i8* @malloc(i64 %354)
%356 = bitcast i8* %355 to i32*
store i32* %356, i32** %54
%357 = load i32, i32* %10
%358 = icmp sgt i32 %357, 1
br i1 %358, label %359, label %384
359: ; preds = %336
store i32 0, i32* %37
br label %360
360: ; preds = %380, %359
%361 = load i32, i32* %37
%362 = load i32, i32* %10
%363 = icmp slt i32 %361, %362
br i1 %363, label %364, label %383
364: ; preds = %360
%365 = load double**, double*** %32
%366 = load i32, i32* %37
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double*, double** %365, i64 %367
%369 = load double*, double** %368
%370 = bitcast double* %369 to i8*
%371 = load double**, double*** %9
%372 = load i32, i32* %37
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double*, double** %371, i64 %373
%375 = load double*, double** %374
%376 = bitcast double* %375 to i8*
%377 = load i32, i32* %12
%378 = sext i32 %377 to i64
%379 = mul i64 %378, 8
br label %380
380: ; preds = %364
%381 = load i32, i32* %37
%382 = add nsw i32 %381, 1
store i32 %382, i32* %37
br label %360
383: ; preds = %360
br label %384
384: ; preds = %383, %336
%385 = load i32, i32* %11
%386 = icmp sgt i32 %385, 1
br i1 %386, label %387, label %414
387: ; preds = %384
store i32 0, i32* %37
br label %388
388: ; preds = %410, %387
%389 = load i32, i32* %37
%390 = load i32, i32* %11
%391 = icmp slt i32 %389, %390
br i1 %391, label %392, label %413
392: ; preds = %388
%393 = load double**, double*** %33
%394 = load i32, i32* %37
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double*, double** %393, i64 %395
%397 = load double*, double** %396
%398 = bitcast double* %397 to i8*
%399 = load double**, double*** %9
%400 = load i32, i32* %37
%401 = load i32, i32* %10
%402 = add nsw i32 %400, %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double*, double** %399, i64 %403
%405 = load double*, double** %404
%406 = bitcast double* %405 to i8*
%407 = load i32, i32* %12
%408 = sext i32 %407 to i64
%409 = mul i64 %408, 8
br label %410
410: ; preds = %392
%411 = load i32, i32* %37
%412 = add nsw i32 %411, 1
store i32 %412, i32* %37
br label %388
413: ; preds = %388
br label %414
414: ; preds = %413, %384
%415 = load double**, double*** %9
%416 = load i32, i32* %10
%417 = load i32, i32* %11
%418 = add nsw i32 %416, %417
%419 = load i32, i32* %12
%420 = load i32, i32* %10
%421 = load i32, i32* %38
%422 = load i32, i32* %56
%423 = load i32*, i32** %52
%424 = load i32**, i32*** %40
%425 = load i32*, i32** %43
%426 = 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** %415, i32 %418, i32 %419, i32 0, i32 %420, i32 %421, i32 %422, i32* %423, i32** %424, i32* %425)
%427 = load i32, i32* %10
%428 = icmp eq i32 %427, 1
br i1 %428, label %429, label %443
429: ; preds = %414
%430 = load double*, double** %15
%431 = getelementptr inbounds double, double* %430, i64 0
%432 = load double, double* %431
store double %432, double* %34
%433 = load double**, double*** %9
%434 = getelementptr inbounds double*, double** %433, i64 0
%435 = load double*, double** %434
%436 = load i32, i32* %12
%437 = load double, double* %34
%438 = load i32, i32* %39
%439 = load i32*, i32** %46
%440 = load i32*, i32** %49
%441 = load i32*, i32** %50
%442 = call i32 (double*, i32, double, i32, i32*, i32*, i32*, ...) bitcast (i32 (...)* @make_box1 to i32 (double*, i32, double, i32, i32*, i32*, i32*, ...)*)(double* %435, i32 %436, double %437, i32 %438, i32* %439, i32* %440, i32* %441)
br label %455
443: ; preds = %414
%444 = load double**, double*** %32
%445 = load i32, i32* %10
%446 = load i32, i32* %12
%447 = load i32, i32* %10
%448 = sub nsw i32 %447, 1
%449 = load i32, i32* %38
%450 = load i32, i32* %56
%451 = load i32*, i32** %53
%452 = load i32**, i32*** %42
%453 = load i32*, i32** %45
%454 = 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** %444, i32 %445, i32 %446, i32 0, i32 %448, i32 %449, i32 %450, i32* %451, i32** %452, i32* %453)
br label %455
455: ; preds = %443, %429
%456 = load i32, i32* %11
%457 = icmp eq i32 %456, 1
br i1 %457, label %458, label %476
458: ; preds = %455
%459 = load double*, double** %15
%460 = load i32, i32* %10
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %459, i64 %461
%463 = load double, double* %462
store double %463, double* %35
%464 = load double**, double*** %9
%465 = load i32, i32* %10
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds double*, double** %464, i64 %466
%468 = load double*, double** %467
%469 = load i32, i32* %12
%470 = load double, double* %35
%471 = load i32, i32* %39
%472 = load i32*, i32** %47
%473 = load i32*, i32** %48
%474 = load i32*, i32** %51
%475 = call i32 (double*, i32, double, i32, i32*, i32*, i32*, ...) bitcast (i32 (...)* @make_box1 to i32 (double*, i32, double, i32, i32*, i32*, i32*, ...)*)(double* %468, i32 %469, double %470, i32 %471, i32* %472, i32* %473, i32* %474)
br label %488
476: ; preds = %455
%477 = load double**, double*** %33
%478 = load i32, i32* %11
%479 = load i32, i32* %12
%480 = load i32, i32* %11
%481 = sub nsw i32 %480, 1
%482 = load i32, i32* %38
%483 = load i32, i32* %56
%484 = load i32*, i32** %54
%485 = load i32**, i32*** %41
%486 = load i32*, i32** %44
%487 = 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** %477, i32 %478, i32 %479, i32 0, i32 %481, i32 %482, i32 %483, i32* %484, i32** %485, i32* %486)
br label %488
488: ; preds = %476, %458
store i32 0, i32* %18
br label %489
489: ; preds = %502, %488
%490 = load i32, i32* %18
%491 = load i32, i32* %13
%492 = icmp slt i32 %490, %491
br i1 %492, label %493, label %505
493: ; preds = %489
%494 = load double*, double** %31
%495 = load i32, i32* %18
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %494, i64 %496
store double 0.000000e+00, double* %497
%498 = load double*, double** %30
%499 = load i32, i32* %18
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
store double 0.000000e+00, double* %501
br label %502
502: ; preds = %493
%503 = load i32, i32* %18
%504 = add nsw i32 %503, 1
store i32 %504, i32* %18
br label %489
505: ; preds = %489
store i32 0, i32* %17
br label %506
506: ; preds = %1015, %505
%507 = load i32, i32* %17
%508 = load i32, i32* %12
%509 = icmp slt i32 %507, %508
br i1 %509, label %510, label %1018
510: ; preds = %506
store i32 0, i32* %37
br label %511
511: ; preds = %535, %510
%512 = load i32, i32* %37
%513 = load i32, i32* %10
%514 = load i32, i32* %11
%515 = add nsw i32 %513, %514
%516 = icmp slt i32 %512, %515
br i1 %516, label %517, label %538
517: ; preds = %511
%518 = load double**, double*** %9
%519 = load i32, i32* %37
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double*, double** %518, i64 %520
%522 = load double*, double** %521
%523 = load i32*, i32** %52
%524 = load i32, i32* %17
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds i32, i32* %523, i64 %525
%527 = load i32, i32* %526
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %522, i64 %528
%530 = load double, double* %529
%531 = load double*, double** %24
%532 = load i32, i32* %37
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %531, i64 %533
store double %530, double* %534
br label %535
535: ; preds = %517
%536 = load i32, i32* %37
%537 = add nsw i32 %536, 1
store i32 %537, i32* %37
br label %511
538: ; preds = %511
%539 = load double**, double*** %9
%540 = load i32, i32* %10
%541 = load i32, i32* %11
%542 = add nsw i32 %540, %541
%543 = load i32, i32* %10
%544 = load i32*, i32** %52
%545 = load i32, i32* %17
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i32, i32* %544, i64 %546
%548 = load i32, i32* %547
%549 = load i32, i32* %38
%550 = load double, double* %55
%551 = load i32, i32* %13
%552 = load i32**, i32*** %40
%553 = load i32*, i32** %43
%554 = load i32*, i32** %36
%555 = 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** %539, i32 %542, i32 0, i32 %543, i32 %548, i32 %549, double %550, i32 %551, i32** %552, i32* %553, i32* %554)
store i32 0, i32* %18
br label %556
556: ; preds = %1011, %538
%557 = load i32, i32* %18
%558 = load i32, i32* %13
%559 = icmp slt i32 %557, %558
br i1 %559, label %560, label %1014
560: ; preds = %556
%561 = load double*, double** %27
%562 = load i32, i32* %18
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %561, i64 %563
store double 0.000000e+00, double* %564
store i32 0, i32* %37
br label %565
565: ; preds = %613, %560
%566 = load i32, i32* %37
%567 = load i32, i32* %10
%568 = icmp slt i32 %566, %567
br i1 %568, label %569, label %616
569: ; preds = %565
store i32 1, i32* %19
br label %570
570: ; preds = %609, %569
%571 = load i32, i32* %19
%572 = load i32, i32* %18
%573 = add nsw i32 %572, 1
%574 = icmp sle i32 %571, %573
br i1 %574, label %575, label %612
575: ; preds = %570
%576 = load double*, double** %24
%577 = load i32, i32* %37
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double, double* %576, i64 %578
%580 = load double, double* %579
%581 = load double**, double*** %9
%582 = load i32, i32* %37
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double*, double** %581, i64 %583
%585 = load double*, double** %584
%586 = load i32*, i32** %36
%587 = load i32, i32* %19
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds i32, i32* %586, i64 %588
%590 = load i32, i32* %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %585, i64 %591
%593 = load double, double* %592
%594 = fsub double %580, %593
%595 = call double @llvm.fabs.f64(double %594)
store double %595, double* %26
%596 = load double*, double** %27
%597 = load i32, i32* %18
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %596, i64 %598
%600 = load double, double* %599
%601 = fcmp ogt double %595, %600
br i1 %601, label %602, label %608
602: ; preds = %575
%603 = load double, double* %26
%604 = load double*, double** %27
%605 = load i32, i32* %18
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %604, i64 %606
store double %603, double* %607
br label %608
608: ; preds = %602, %575
br label %609
609: ; preds = %608
%610 = load i32, i32* %19
%611 = add nsw i32 %610, 1
store i32 %611, i32* %19
br label %570
612: ; preds = %570
br label %613
613: ; preds = %612
%614 = load i32, i32* %37
%615 = add nsw i32 %614, 1
store i32 %615, i32* %37
br label %565
616: ; preds = %565
%617 = load double*, double** %28
%618 = load i32, i32* %18
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds double, double* %617, i64 %619
store double 0.000000e+00, double* %620
%621 = load i32, i32* %10
store i32 %621, i32* %37
br label %622
622: ; preds = %672, %616
%623 = load i32, i32* %37
%624 = load i32, i32* %10
%625 = load i32, i32* %11
%626 = add nsw i32 %624, %625
%627 = icmp slt i32 %623, %626
br i1 %627, label %628, label %675
628: ; preds = %622
store i32 1, i32* %19
br label %629
629: ; preds = %668, %628
%630 = load i32, i32* %19
%631 = load i32, i32* %18
%632 = add nsw i32 %631, 1
%633 = icmp sle i32 %630, %632
br i1 %633, label %634, label %671
634: ; preds = %629
%635 = load double*, double** %24
%636 = load i32, i32* %37
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
%639 = load double, double* %638
%640 = load double**, double*** %9
%641 = load i32, i32* %37
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double*, double** %640, i64 %642
%644 = load double*, double** %643
%645 = load i32*, i32** %36
%646 = load i32, i32* %19
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds i32, i32* %645, i64 %647
%649 = load i32, i32* %648
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %644, i64 %650
%652 = load double, double* %651
%653 = fsub double %639, %652
%654 = call double @llvm.fabs.f64(double %653)
store double %654, double* %25
%655 = load double*, double** %28
%656 = load i32, i32* %18
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double, double* %655, i64 %657
%659 = load double, double* %658
%660 = fcmp ogt double %654, %659
br i1 %660, label %661, label %667
661: ; preds = %634
%662 = load double, double* %25
%663 = load double*, double** %28
%664 = load i32, i32* %18
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
store double %662, double* %666
br label %667
667: ; preds = %661, %634
br label %668
668: ; preds = %667
%669 = load i32, i32* %19
%670 = add nsw i32 %669, 1
store i32 %670, i32* %19
br label %629
671: ; preds = %629
br label %672
672: ; preds = %671
%673 = load i32, i32* %37
%674 = add nsw i32 %673, 1
store i32 %674, i32* %37
br label %622
675: ; preds = %622
%676 = load i32, i32* %10
%677 = icmp sgt i32 %676, 1
br i1 %677, label %678, label %702
678: ; preds = %675
%679 = load double**, double*** %32
%680 = load i32*, i32** %53
%681 = load i32, i32* %17
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds i32, i32* %680, i64 %682
%684 = load i32, i32* %683
%685 = load i32, i32* %10
%686 = sub nsw i32 %685, 1
%687 = load i32, i32* %10
%688 = load i32, i32* %38
%689 = load double, double* %55
%690 = load double*, double** %27
%691 = load i32, i32* %18
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds double, double* %690, i64 %692
%694 = load double, double* %693
%695 = load i32**, i32*** %42
%696 = load i32*, i32** %45
%697 = call i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...) bitcast (i32 (...)* @neiE to i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...)*)(double** %679, i32 %684, i32 0, i32 %686, i32 %687, i32 %688, double %689, double %694, i32** %695, i32* %696)
%698 = load i32*, i32** %22
%699 = load i32, i32* %18
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i32, i32* %698, i64 %700
store i32 %697, i32* %701
br label %726
702: ; preds = %675
%703 = load double**, double*** %9
%704 = getelementptr inbounds double*, double** %703, i64 0
%705 = load double*, double** %704
%706 = load i32*, i32** %52
%707 = load i32, i32* %17
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds i32, i32* %706, i64 %708
%710 = load i32, i32* %709
%711 = load double, double* %34
%712 = load i32, i32* %39
%713 = load double*, double** %27
%714 = load i32, i32* %18
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds double, double* %713, i64 %715
%717 = load double, double* %716
%718 = load i32*, i32** %46
%719 = load i32*, i32** %49
%720 = load i32*, i32** %50
%721 = call i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...) bitcast (i32 (...)* @neiE1 to i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...)*)(double* %705, i32 %710, double %711, i32 %712, double %717, i32* %718, i32* %719, i32* %720)
%722 = load i32*, i32** %22
%723 = load i32, i32* %18
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds i32, i32* %722, i64 %724
store i32 %721, i32* %725
br label %726
726: ; preds = %702, %678
%727 = load i32, i32* %11
%728 = icmp sgt i32 %727, 1
br i1 %728, label %729, label %753
729: ; preds = %726
%730 = load double**, double*** %33
%731 = load i32*, i32** %54
%732 = load i32, i32* %17
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds i32, i32* %731, i64 %733
%735 = load i32, i32* %734
%736 = load i32, i32* %11
%737 = sub nsw i32 %736, 1
%738 = load i32, i32* %11
%739 = load i32, i32* %38
%740 = load double, double* %55
%741 = load double*, double** %28
%742 = load i32, i32* %18
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds double, double* %741, i64 %743
%745 = load double, double* %744
%746 = load i32**, i32*** %41
%747 = load i32*, i32** %44
%748 = call i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...) bitcast (i32 (...)* @neiE to i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...)*)(double** %730, i32 %735, i32 0, i32 %737, i32 %738, i32 %739, double %740, double %745, i32** %746, i32* %747)
%749 = load i32*, i32** %23
%750 = load i32, i32* %18
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds i32, i32* %749, i64 %751
store i32 %748, i32* %752
br label %779
753: ; preds = %726
%754 = load double**, double*** %9
%755 = load i32, i32* %10
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds double*, double** %754, i64 %756
%758 = load double*, double** %757
%759 = load i32*, i32** %52
%760 = load i32, i32* %17
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds i32, i32* %759, i64 %761
%763 = load i32, i32* %762
%764 = load double, double* %35
%765 = load i32, i32* %39
%766 = load double*, double** %28
%767 = load i32, i32* %18
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds double, double* %766, i64 %768
%770 = load double, double* %769
%771 = load i32*, i32** %47
%772 = load i32*, i32** %48
%773 = load i32*, i32** %51
%774 = call i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...) bitcast (i32 (...)* @neiE1 to i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...)*)(double* %758, i32 %763, double %764, i32 %765, double %770, i32* %771, i32* %772, i32* %773)
%775 = load i32*, i32** %23
%776 = load i32, i32* %18
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds i32, i32* %775, i64 %777
store i32 %774, i32* %778
br label %779
779: ; preds = %753, %729
%780 = load double*, double** %27
%781 = load i32, i32* %18
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds double, double* %780, i64 %782
%784 = load double, double* %783
%785 = load double*, double** %28
%786 = load i32, i32* %18
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %785, i64 %787
%789 = load double, double* %788
%790 = fcmp ogt double %784, %789
br i1 %790, label %791, label %889
791: ; preds = %779
%792 = load double*, double** %27
%793 = load i32, i32* %18
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %792, i64 %794
%796 = load double, double* %795
%797 = load double*, double** %29
%798 = load i32, i32* %18
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %797, i64 %799
store double %796, double* %800
%801 = load i32*, i32** %22
%802 = load i32, i32* %18
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds i32, i32* %801, i64 %803
%805 = load i32, i32* %804
%806 = load i32*, i32** %20
%807 = load i32, i32* %18
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds i32, i32* %806, i64 %808
store i32 %805, i32* %809
%810 = load i32, i32* %11
%811 = icmp sgt i32 %810, 1
br i1 %811, label %812, label %836
812: ; preds = %791
%813 = load double**, double*** %33
%814 = load i32*, i32** %54
%815 = load i32, i32* %17
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds i32, i32* %814, i64 %816
%818 = load i32, i32* %817
%819 = load i32, i32* %11
%820 = sub nsw i32 %819, 1
%821 = load i32, i32* %11
%822 = load i32, i32* %38
%823 = load double, double* %55
%824 = load double*, double** %29
%825 = load i32, i32* %18
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds double, double* %824, i64 %826
%828 = load double, double* %827
%829 = load i32**, i32*** %41
%830 = load i32*, i32** %44
%831 = call i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...) bitcast (i32 (...)* @neiE to i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...)*)(double** %813, i32 %818, i32 0, i32 %820, i32 %821, i32 %822, double %823, double %828, i32** %829, i32* %830)
%832 = load i32*, i32** %21
%833 = load i32, i32* %18
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds i32, i32* %832, i64 %834
store i32 %831, i32* %835
br label %862
836: ; preds = %791
%837 = load double**, double*** %9
%838 = load i32, i32* %10
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds double*, double** %837, i64 %839
%841 = load double*, double** %840
%842 = load i32*, i32** %52
%843 = load i32, i32* %17
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds i32, i32* %842, i64 %844
%846 = load i32, i32* %845
%847 = load double, double* %35
%848 = load i32, i32* %39
%849 = load double*, double** %29
%850 = load i32, i32* %18
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds double, double* %849, i64 %851
%853 = load double, double* %852
%854 = load i32*, i32** %47
%855 = load i32*, i32** %48
%856 = load i32*, i32** %51
%857 = call i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...) bitcast (i32 (...)* @neiE1 to i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...)*)(double* %841, i32 %846, double %847, i32 %848, double %853, i32* %854, i32* %855, i32* %856)
%858 = load i32*, i32** %21
%859 = load i32, i32* %18
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds i32, i32* %858, i64 %860
store i32 %857, i32* %861
br label %862
862: ; preds = %836, %812
%863 = load double*, double** %14
%864 = load i32*, i32** %20
%865 = load i32, i32* %18
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds i32, i32* %864, i64 %866
%868 = load i32, i32* %867
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds double, double* %863, i64 %869
%871 = load double, double* %870
%872 = load double*, double** %14
%873 = load i32*, i32** %21
%874 = load i32, i32* %18
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds i32, i32* %873, i64 %875
%877 = load i32, i32* %876
%878 = add nsw i32 %877, 1
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds double, double* %872, i64 %879
%881 = load double, double* %880
%882 = fadd double %871, %881
%883 = load double*, double** %30
%884 = load i32, i32* %18
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds double, double* %883, i64 %885
%887 = load double, double* %886
%888 = fadd double %887, %882
store double %888, double* %886
br label %985
889: ; preds = %779
%890 = load double*, double** %28
%891 = load i32, i32* %18
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds double, double* %890, i64 %892
%894 = load double, double* %893
%895 = load double*, double** %29
%896 = load i32, i32* %18
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds double, double* %895, i64 %897
store double %894, double* %898
%899 = load i32*, i32** %23
%900 = load i32, i32* %18
%901 = sext i32 %900 to i64
%902 = getelementptr inbounds i32, i32* %899, i64 %901
%903 = load i32, i32* %902
%904 = load i32*, i32** %21
%905 = load i32, i32* %18
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds i32, i32* %904, i64 %906
store i32 %903, i32* %907
%908 = load i32, i32* %10
%909 = icmp sgt i32 %908, 1
br i1 %909, label %910, label %934
910: ; preds = %889
%911 = load double**, double*** %32
%912 = load i32*, i32** %53
%913 = load i32, i32* %17
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds i32, i32* %912, i64 %914
%916 = load i32, i32* %915
%917 = load i32, i32* %10
%918 = sub nsw i32 %917, 1
%919 = load i32, i32* %10
%920 = load i32, i32* %38
%921 = load double, double* %55
%922 = load double*, double** %29
%923 = load i32, i32* %18
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds double, double* %922, i64 %924
%926 = load double, double* %925
%927 = load i32**, i32*** %42
%928 = load i32*, i32** %45
%929 = call i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...) bitcast (i32 (...)* @neiE to i32 (double**, i32, i32, i32, i32, i32, double, double, i32**, i32*, ...)*)(double** %911, i32 %916, i32 0, i32 %918, i32 %919, i32 %920, double %921, double %926, i32** %927, i32* %928)
%930 = load i32*, i32** %20
%931 = load i32, i32* %18
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds i32, i32* %930, i64 %932
store i32 %929, i32* %933
br label %958
934: ; preds = %889
%935 = load double**, double*** %9
%936 = getelementptr inbounds double*, double** %935, i64 0
%937 = load double*, double** %936
%938 = load i32*, i32** %52
%939 = load i32, i32* %17
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds i32, i32* %938, i64 %940
%942 = load i32, i32* %941
%943 = load double, double* %34
%944 = load i32, i32* %39
%945 = load double*, double** %29
%946 = load i32, i32* %18
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %945, i64 %947
%949 = load double, double* %948
%950 = load i32*, i32** %46
%951 = load i32*, i32** %49
%952 = load i32*, i32** %50
%953 = call i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...) bitcast (i32 (...)* @neiE1 to i32 (double*, i32, double, i32, double, i32*, i32*, i32*, ...)*)(double* %937, i32 %942, double %943, i32 %944, double %949, i32* %950, i32* %951, i32* %952)
%954 = load i32*, i32** %20
%955 = load i32, i32* %18
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds i32, i32* %954, i64 %956
store i32 %953, i32* %957
br label %958
958: ; preds = %934, %910
%959 = load double*, double** %14
%960 = load i32*, i32** %20
%961 = load i32, i32* %18
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds i32, i32* %960, i64 %962
%964 = load i32, i32* %963
%965 = add nsw i32 %964, 1
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds double, double* %959, i64 %966
%968 = load double, double* %967
%969 = load double*, double** %14
%970 = load i32*, i32** %21
%971 = load i32, i32* %18
%972 = sext i32 %971 to i64
%973 = getelementptr inbounds i32, i32* %970, i64 %972
%974 = load i32, i32* %973
%975 = sext i32 %974 to i64
%976 = getelementptr inbounds double, double* %969, i64 %975
%977 = load double, double* %976
%978 = fadd double %968, %977
%979 = load double*, double** %30
%980 = load i32, i32* %18
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds double, double* %979, i64 %981
%983 = load double, double* %982
%984 = fadd double %983, %978
store double %984, double* %982
br label %985
985: ; preds = %958, %862
%986 = load double*, double** %14
%987 = load i32*, i32** %22
%988 = load i32, i32* %18
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds i32, i32* %987, i64 %989
%991 = load i32, i32* %990
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds double, double* %986, i64 %992
%994 = load double, double* %993
%995 = load double*, double** %14
%996 = load i32*, i32** %23
%997 = load i32, i32* %18
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds i32, i32* %996, i64 %998
%1000 = load i32, i32* %999
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds double, double* %995, i64 %1001
%1003 = load double, double* %1002
%1004 = fadd double %994, %1003
%1005 = load double*, double** %31
%1006 = load i32, i32* %18
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds double, double* %1005, i64 %1007
%1009 = load double, double* %1008
%1010 = fadd double %1009, %1004
store double %1010, double* %1008
br label %1011
1011: ; preds = %985
%1012 = load i32, i32* %18
%1013 = add nsw i32 %1012, 1
store i32 %1013, i32* %18
br label %556
1014: ; preds = %556
br label %1015
1015: ; preds = %1014
%1016 = load i32, i32* %17
%1017 = add nsw i32 %1016, 1
store i32 %1017, i32* %17
br label %506
1018: ; preds = %506
store i32 0, i32* %18
br label %1019
1019: ; preds = %1087, %1018
%1020 = load i32, i32* %18
%1021 = load i32, i32* %13
%1022 = icmp slt i32 %1020, %1021
br i1 %1022, label %1023, label %1090
1023: ; preds = %1019
%1024 = load i32, i32* %12
%1025 = sitofp i32 %1024 to double
%1026 = load double*, double** %30
%1027 = load i32, i32* %18
%1028 = sext i32 %1027 to i64
%1029 = getelementptr inbounds double, double* %1026, i64 %1028
%1030 = load double, double* %1029
%1031 = fdiv double %1030, %1025
store double %1031, double* %1029
%1032 = load double*, double** %14
%1033 = load i32, i32* %12
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds double, double* %1032, i64 %1034
%1036 = load double, double* %1035
%1037 = load double*, double** %14
%1038 = load i32, i32* %18
%1039 = add nsw i32 %1038, 1
%1040 = sext i32 %1039 to i64
%1041 = getelementptr inbounds double, double* %1037, i64 %1040
%1042 = load double, double* %1041
%1043 = fadd double %1036, %1042
%1044 = load double*, double** %30
%1045 = load i32, i32* %18
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds double, double* %1044, i64 %1046
%1048 = load double, double* %1047
%1049 = fsub double %1043, %1048
%1050 = load double*, double** %16
%1051 = load i32, i32* %18
%1052 = mul nsw i32 2, %1051
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds double, double* %1050, i64 %1053
store double %1049, double* %1054
%1055 = load i32, i32* %12
%1056 = sitofp i32 %1055 to double
%1057 = load double*, double** %31
%1058 = load i32, i32* %18
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds double, double* %1057, i64 %1059
%1061 = load double, double* %1060
%1062 = fdiv double %1061, %1056
store double %1062, double* %1060
%1063 = load double*, double** %14
%1064 = load i32, i32* %12
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds double, double* %1063, i64 %1065
%1067 = load double, double* %1066
%1068 = load double*, double** %57
%1069 = load i32, i32* %18
%1070 = add nsw i32 %1069, 1
%1071 = sext i32 %1070 to i64
%1072 = getelementptr inbounds double, double* %1068, i64 %1071
%1073 = load double, double* %1072
%1074 = fadd double %1067, %1073
%1075 = load double*, double** %31
%1076 = load i32, i32* %18
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds double, double* %1075, i64 %1077
%1079 = load double, double* %1078
%1080 = fsub double %1074, %1079
%1081 = load double*, double** %16
%1082 = load i32, i32* %18
%1083 = mul nsw i32 2, %1082
%1084 = add nsw i32 %1083, 1
%1085 = sext i32 %1084 to i64
%1086 = getelementptr inbounds double, double* %1081, i64 %1085
store double %1080, double* %1086
br label %1087
1087: ; preds = %1023
%1088 = load i32, i32* %18
%1089 = add nsw i32 %1088, 1
store i32 %1089, i32* %18
br label %1019
1090: ; preds = %1019
%1091 = load double*, double** %24
%1092 = bitcast double* %1091 to i8*
%1093 = load i32*, i32** %36
%1094 = bitcast i32* %1093 to i8*
%1095 = load i32*, i32** %43
%1096 = bitcast i32* %1095 to i8*
store i32 0, i32* %17
br label %1097
1097: ; preds = %1108, %1090
%1098 = load i32, i32* %17
%1099 = load i32, i32* %38
%1100 = icmp slt i32 %1098, %1099
br i1 %1100, label %1101, label %1111
1101: ; preds = %1097
%1102 = load i32**, i32*** %40
%1103 = load i32, i32* %17
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds i32*, i32** %1102, i64 %1104
%1106 = load i32*, i32** %1105
%1107 = bitcast i32* %1106 to i8*
br label %1108
1108: ; preds = %1101
%1109 = load i32, i32* %17
%1110 = add nsw i32 %1109, 1
store i32 %1110, i32* %17
br label %1097
1111: ; preds = %1097
%1112 = load i32**, i32*** %40
%1113 = bitcast i32** %1112 to i8*
%1114 = load i32*, i32** %52
%1115 = bitcast i32* %1114 to i8*
%1116 = load i32*, i32** %53
%1117 = bitcast i32* %1116 to i8*
%1118 = load i32*, i32** %54
%1119 = bitcast i32* %1118 to i8*
%1120 = load i32, i32* %10
%1121 = icmp eq i32 %1120, 1
br i1 %1121, label %1122, label %1129
1122: ; preds = %1111
%1123 = load i32*, i32** %50
%1124 = bitcast i32* %1123 to i8*
%1125 = load i32*, i32** %46
%1126 = bitcast i32* %1125 to i8*
%1127 = load i32*, i32** %49
%1128 = bitcast i32* %1127 to i8*
br label %1166
1129: ; preds = %1111
store i32 0, i32* %17
br label %1130
1130: ; preds = %1141, %1129
%1131 = load i32, i32* %17
%1132 = load i32, i32* %38
%1133 = icmp slt i32 %1131, %1132
br i1 %1133, label %1134, label %1144
1134: ; preds = %1130
%1135 = load i32**, i32*** %42
%1136 = load i32, i32* %17
%1137 = sext i32 %1136 to i64
%1138 = getelementptr inbounds i32*, i32** %1135, i64 %1137
%1139 = load i32*, i32** %1138
%1140 = bitcast i32* %1139 to i8*
br label %1141
1141: ; preds = %1134
%1142 = load i32, i32* %17
%1143 = add nsw i32 %1142, 1
store i32 %1143, i32* %17
br label %1130
1144: ; preds = %1130
%1145 = load i32**, i32*** %42
%1146 = bitcast i32** %1145 to i8*
%1147 = load i32*, i32** %45
%1148 = bitcast i32* %1147 to i8*
store i32 0, i32* %37
br label %1149
1149: ; preds = %1160, %1144
%1150 = load i32, i32* %37
%1151 = load i32, i32* %10
%1152 = icmp slt i32 %1150, %1151
br i1 %1152, label %1153, label %1163
1153: ; preds = %1149
%1154 = load double**, double*** %32
%1155 = load i32, i32* %37
%1156 = sext i32 %1155 to i64
%1157 = getelementptr inbounds double*, double** %1154, i64 %1156
%1158 = load double*, double** %1157
%1159 = bitcast double* %1158 to i8*
br label %1160
1160: ; preds = %1153
%1161 = load i32, i32* %37
%1162 = add nsw i32 %1161, 1
store i32 %1162, i32* %37
br label %1149
1163: ; preds = %1149
%1164 = load double**, double*** %32
%1165 = bitcast double** %1164 to i8*
br label %1166
1166: ; preds = %1163, %1122
%1167 = load i32, i32* %11
%1168 = icmp eq i32 %1167, 1
br i1 %1168, label %1169, label %1176
1169: ; preds = %1166
%1170 = load i32*, i32** %51
%1171 = bitcast i32* %1170 to i8*
%1172 = load i32*, i32** %47
%1173 = bitcast i32* %1172 to i8*
%1174 = load i32*, i32** %48
%1175 = bitcast i32* %1174 to i8*
br label %1213
1176: ; preds = %1166
store i32 0, i32* %17
br label %1177
1177: ; preds = %1188, %1176
%1178 = load i32, i32* %17
%1179 = load i32, i32* %38
%1180 = icmp slt i32 %1178, %1179
br i1 %1180, label %1181, label %1191
1181: ; preds = %1177
%1182 = load i32**, i32*** %41
%1183 = load i32, i32* %17
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds i32*, i32** %1182, i64 %1184
%1186 = load i32*, i32** %1185
%1187 = bitcast i32* %1186 to i8*
br label %1188
1188: ; preds = %1181
%1189 = load i32, i32* %17
%1190 = add nsw i32 %1189, 1
store i32 %1190, i32* %17
br label %1177
1191: ; preds = %1177
%1192 = load i32**, i32*** %41
%1193 = bitcast i32** %1192 to i8*
%1194 = load i32*, i32** %44
%1195 = bitcast i32* %1194 to i8*
store i32 0, i32* %37
br label %1196
1196: ; preds = %1207, %1191
%1197 = load i32, i32* %37
%1198 = load i32, i32* %11
%1199 = icmp slt i32 %1197, %1198
br i1 %1199, label %1200, label %1210
1200: ; preds = %1196
%1201 = load double**, double*** %33
%1202 = load i32, i32* %37
%1203 = sext i32 %1202 to i64
%1204 = getelementptr inbounds double*, double** %1201, i64 %1203
%1205 = load double*, double** %1204
%1206 = bitcast double* %1205 to i8*
br label %1207
1207: ; preds = %1200
%1208 = load i32, i32* %37
%1209 = add nsw i32 %1208, 1
store i32 %1209, i32* %37
br label %1196
1210: ; preds = %1196
%1211 = load double**, double*** %33
%1212 = bitcast double** %1211 to i8*
br label %1213
1213: ; preds = %1210, %1169
%1214 = load double*, double** %57
%1215 = bitcast double* %1214 to i8*
%1216 = load double*, double** %27
%1217 = bitcast double* %1216 to i8*
%1218 = load double*, double** %28
%1219 = bitcast double* %1218 to i8*
%1220 = load double*, double** %29
%1221 = bitcast double* %1220 to i8*
%1222 = load i32*, i32** %20
%1223 = bitcast i32* %1222 to i8*
%1224 = load i32*, i32** %22
%1225 = bitcast i32* %1224 to i8*
%1226 = load i32*, i32** %21
%1227 = bitcast i32* %1226 to i8*
%1228 = load i32*, i32** %23
%1229 = bitcast i32* %1228 to i8*
%1230 = load double*, double** %30
%1231 = bitcast double* %1230 to i8*
%1232 = load double*, double** %31
%1233 = bitcast double* %1232 to i8*
ret void
}

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