void mic_xnyn(double **x, int dimx, int dimy, int N, int K, double *psi,
              double *scal, double *mic) {
  int i, k, nx1, ny1;
  double *xc, dy, dx;
  double epsx, epsy, Eps;
  double dxy1;
  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;
  nn = (int *)malloc((K + 1) * sizeof(int));
  xc = (double *)malloc((dimx + dimy) * 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);
  dxy1 = 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);
    epsx = 0;
    for (d = 0; d < dimx; d++)
      for (k = 1; k <= K; k++)
        if ((dx = fabs(xc[d] - x[d][nn[k]])) > epsx)
          epsx = dx;
    epsy = 0;
    for (d = dimx; d < dimx + dimy; d++)
      for (k = 1; k <= K; k++)
        if ((dy = fabs(xc[d] - x[d][nn[k]])) > epsy)
          epsy = dy;
    if (epsx > epsy) {
      Eps = epsx;
    } else {
      Eps = epsy;
    }
    if (dimy > 1)
      ny1 = neiE(yy, indy[i], 0, dimy - 1, dimy, BOX, epsilon, Eps, boxy, lisy);
    else
      ny1 = neiE1(x[dimx], ind[i], scaly, BOX1, Eps, boxy1, lisy1, myi);
    if (dimx > 1)
      nx1 = neiE(xx, indx[i], 0, dimx - 1, dimx, BOX, epsilon, Eps, boxx, lisx);
    else
      nx1 = neiE1(x[0], ind[i], scalx, BOX1, Eps, boxx1, lisx1, mxi);
    if (epsx > epsy) {
      dxy1 += psi[nx1] + psi[ny1 + 1];
    } else {
      dxy1 += psi[nx1 + 1] + psi[ny1];
    }
  }
  dxy1 /= N;
  *mic = psi[N] + psi[K] - dxy1;
  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);
  }
}


x86 assembly (clang, -O0):
<mic_xnyn>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x148,%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    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0xa0(%rbp)
cvtsi2sdl -0xa0(%rbp),%xmm0
ff
movsd  0xe0e(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0xa0(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    122e <mic_xnyn+0xae>
mov    -0xa0(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    11e2 <mic_xnyn+0x62>
cvtsi2sdl -0xa0(%rbp),%xmm1
ff
movsd  0xdca(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0xa0(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x12c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    1347 <mic_xnyn+0x1c7>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d1 <mic_xnyn+0x151>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    128f <mic_xnyn+0x10f>
movslq -0xa0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    132e <mic_xnyn+0x1ae>
movslq -0xa0(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xc0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ef <mic_xnyn+0x16f>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd8(%rbp)
jmp    1393 <mic_xnyn+0x213>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf8(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x100(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    1470 <mic_xnyn+0x2f0>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13fa <mic_xnyn+0x27a>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x80(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    13b8 <mic_xnyn+0x238>
movslq -0xa0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1457 <mic_xnyn+0x2d7>
movslq -0xa0(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1418 <mic_xnyn+0x298>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd0(%rbp)
jmp    14bc <mic_xnyn+0x33c>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf0(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x108(%rbp)
movslq -0xa0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1519 <mic_xnyn+0x399>
movslq -0xa0(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xb0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14da <mic_xnyn+0x35a>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq -0x1c(%rbp),%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)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x120(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    15d0 <mic_xnyn+0x450>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15cb <mic_xnyn+0x44b>
mov    -0x78(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x3,%rdx
call   1080 <memcpy@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    157d <mic_xnyn+0x3fd>
jmp    15d0 <mic_xnyn+0x450>
cmpl   $0x1,-0x18(%rbp)
jle    163c <mic_xnyn+0x4bc>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1637 <mic_xnyn+0x4b7>
mov    -0x80(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x9c(%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    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    15e4 <mic_xnyn+0x464>
jmp    163c <mic_xnyn+0x4bc>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    -0xa0(%rbp),%r9d
mov    -0x12c(%rbp),%ebx
mov    -0x110(%rbp),%r11
mov    -0xb0(%rbp),%r10
mov    -0xc8(%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    16dd <mic_xnyn+0x55d>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xa4(%rbp),%edx
mov    -0xe0(%rbp),%rcx
mov    -0xf8(%rbp),%r8
mov    -0x100(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    172c <mic_xnyn+0x5ac>
mov    -0x78(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xa0(%rbp),%r9d
mov    -0x12c(%rbp),%ebx
mov    -0x118(%rbp),%r11
mov    -0xc0(%rbp),%r10
mov    -0xd8(%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    1789 <mic_xnyn+0x609>
mov    0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xa4(%rbp),%edx
mov    -0xe8(%rbp),%rcx
mov    -0xf0(%rbp),%r8
mov    -0x108(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    17d8 <mic_xnyn+0x658>
mov    -0x80(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xa0(%rbp),%r9d
mov    -0x12c(%rbp),%ebx
mov    -0x120(%rbp),%r11
mov    -0xb8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %ecx,%ecx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   1040 <make_box2ind@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c24 <mic_xnyn+0xaa4>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1858 <mic_xnyn+0x6d8>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x110(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    17fd <mic_xnyn+0x67d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    -0x110(%rbp),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    -0xa0(%rbp),%r9d
movsd  -0x128(%rbp),%xmm0
ff
mov    -0x20(%rbp),%ebx
mov    -0xb0(%rbp),%r11
mov    -0xc8(%rbp),%r10
mov    -0x98(%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>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    196e <mic_xnyn+0x7ee>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1955 <mic_xnyn+0x7d5>
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x98(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x6ec(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
ucomisd -0x58(%rbp),%xmm0
jbe    1942 <mic_xnyn+0x7c2>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1947 <mic_xnyn+0x7c7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18de <mic_xnyn+0x75e>
jmp    195a <mic_xnyn+0x7da>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    18c8 <mic_xnyn+0x748>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1a2a <mic_xnyn+0x8aa>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1a11 <mic_xnyn+0x891>
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x98(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x630(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
ucomisd -0x60(%rbp),%xmm0
jbe    19fe <mic_xnyn+0x87e>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1a03 <mic_xnyn+0x883>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    199a <mic_xnyn+0x81a>
jmp    1a16 <mic_xnyn+0x896>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    197f <mic_xnyn+0x7ff>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1a49 <mic_xnyn+0x8c9>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1a53 <mic_xnyn+0x8d3>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    1ab5 <mic_xnyn+0x935>
mov    -0x80(%rbp),%rdi
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0xa0(%rbp),%r9d
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
mov    -0xb8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x38(%rbp)
jmp    1b01 <mic_xnyn+0x981>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x110(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xa4(%rbp),%edx
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rcx
mov    -0xf0(%rbp),%r8
mov    -0x108(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    1b63 <mic_xnyn+0x9e3>
mov    -0x78(%rbp),%rdi
mov    -0x118(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0xa0(%rbp),%r9d
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
mov    -0xc0(%rbp),%r10
mov    -0xd8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x34(%rbp)
jmp    1baa <mic_xnyn+0xa2a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x110(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xa4(%rbp),%edx
movsd  -0x68(%rbp),%xmm1
mov    -0xe0(%rbp),%rcx
mov    -0xf8(%rbp),%r8
mov    -0x100(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x34(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1be8 <mic_xnyn+0xa68>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1c11 <mic_xnyn+0xa91>
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1c16 <mic_xnyn+0xa96>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17e7 <mic_xnyn+0x667>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1cb7 <mic_xnyn+0xb37>
mov    -0xb0(%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    1c86 <mic_xnyn+0xb06>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
mov    -0x120(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x14(%rbp)
jne    1d1a <mic_xnyn+0xb9a>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
jmp    1db4 <mic_xnyn+0xc34>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1d52 <mic_xnyn+0xbd2>
mov    -0xc0(%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    1d21 <mic_xnyn+0xba1>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dab <mic_xnyn+0xc2b>
mov    -0x78(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1d74 <mic_xnyn+0xbf4>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1de7 <mic_xnyn+0xc67>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
jmp    1e81 <mic_xnyn+0xd01>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
jge    1e1f <mic_xnyn+0xc9f>
mov    -0xb8(%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    1dee <mic_xnyn+0xc6e>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1e78 <mic_xnyn+0xcf8>
mov    -0x80(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1e41 <mic_xnyn+0xcc1>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
add    $0x148,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mic_xnyn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,0x108(%rsp)
mov    %r8d,%r15d
mov    %ecx,%r13d
mov    %edx,%ebx
mov    %esi,%ebp
mov    %rdi,%r14
mov    0x1a8(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0xf0(%rsp)
lea    0x1(%r15),%eax
mov    %eax,0x28(%rsp)
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%r12
mov    %rbx,0x38(%rsp)
mov    %rbp,0x8(%rsp)
lea    (%rbx,%rbp,1),%eax
mov    %eax,0x2c(%rsp)
cltq
mov    %rax,0x160(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %r15,%rcx
mov    %rax,%r15
cvtsi2sd %ecx,%xmm0
cvtsi2sd %r13d,%xmm3
mov    $0x1,%eax
movsd  0xddf(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ebp
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    0x0(%rbp,%rbp,1),%eax
ucomisd %xmm2,%xmm3
ja     1230 <mic_xnyn+0xb0>
movsd  %xmm4,0x40(%rsp)
movsd  %xmm3,0xd8(%rsp)
mov    %rcx,0x88(%rsp)
movslq %r13d,%rbx
mov    %ebp,%eax
mov    %rax,(%rsp)
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
mov    %rbp,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r13,0x60(%rsp)
jl     134e <mic_xnyn+0x1ce>
mov    %eax,%eax
mov    %rax,0x10(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r13
lea    0x0(,%rbx,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x10(%rsp)
jne    12c0 <mic_xnyn+0x140>
mov    %r13,0x30(%rsp)
mov    (%rsp),%rbx
lea    0x0(,%rbx,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x80(%rsp)
lea    0x0(,%rbx,4),%r13
mov    0x48(%rsp),%rax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovae %eax,%ebp
xor    %ebx,%ebx
mov    %r13,%rdi
call   10a0 <malloc@plt>
mov    0x80(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1310 <mic_xnyn+0x190>
mov    0x50(%rsp),%rbx
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0xc0(%rsp)
mov    0x48(%rsp),%rbp
jmp    1388 <mic_xnyn+0x208>
lea    -0x10(,%rbx,4),%r13
ff
mov    %r13,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb8(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r13,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb0(%rsp)
movsd  0xc78(%rip),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    0x38(%rsp),%rax
cmp    $0x2,%eax
jl     1479 <mic_xnyn+0x2f9>
mov    %eax,%eax
mov    %rax,0x10(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r13
lea    0x0(,%rbx,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x10(%rsp)
jne    13d0 <mic_xnyn+0x250>
mov    %r13,0x18(%rsp)
mov    (%rsp),%rbx
lea    0x0(,%rbx,8),%rdi
mov    %rdi,0x10(%rsp)
call   10a0 <malloc@plt>
mov    %rax,0x78(%rsp)
shl    $0x2,%rbx
mov    %rbx,(%rsp)
mov    0x48(%rsp),%rbp
cmp    $0x2,%ebp
mov    $0x1,%r13d
cmovae %ebp,%r13d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%rdi
call   10a0 <malloc@plt>
mov    0x78(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1430 <mic_xnyn+0x2b0>
mov    %r13,0x90(%rsp)
mov    0x50(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0xa0(%rsp)
mov    0x60(%rsp),%rbx
mov    0x10(%rsp),%rdi
jmp    14df <mic_xnyn+0x35f>
lea    -0x10(,%rbx,4),%r13
ff
mov    %r13,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xa8(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r13,%rdi
mov    0x60(%rsp),%rbx
call   10a0 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    (%rsp),%rax
lea    0x0(,%rax,8),%rdi
shl    $0x2,%rax
mov    %rax,(%rsp)
cmp    $0x2,%ebp
mov    $0x1,%eax
cmovae %ebp,%eax
mov    %rax,0x90(%rsp)
movsd  0x68(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
shr    $0x2,%ebp
mov    %rbp,0x110(%rsp)
lea    -0x5(%rbx),%eax
mov    %eax,0x24(%rsp)
call   10a0 <malloc@plt>
mov    %rax,0x10(%rsp)
xor    %ebx,%ebx
mov    0x90(%rsp),%rbp
mov    (%rsp),%r13
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
call   10a0 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1520 <mic_xnyn+0x3a0>
mov    0x50(%rsp),%rax
lea    0x0(,%rax,4),%rbx
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xd0(%rsp)
mov    %rbx,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
jl     1613 <mic_xnyn+0x493>
mov    0x50(%rsp),%rcx
lea    0x0(,%rcx,8),%rbx
mov    %eax,%eax
mov    %rax,0x58(%rsp)
lea    0x0(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %ebp,%ebp
mov    0x30(%rsp),%r13
nopl   (%rax)
mov    0x0(%r13,%rbp,1),%rdi
mov    (%r14,%rbp,1),%rsi
mov    %rbx,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r13,%rbp,1),%rdi
mov    0x8(%r14,%rbp,1),%rsi
mov    %rbx,%rdx
call   1080 <memcpy@plt>
add    $0x10,%rbp
cmp    %rbp,(%rsp)
jne    15c0 <mic_xnyn+0x440>
testb  $0x1,0x58(%rsp)
mov    0x8(%rsp),%rax
je     1613 <mic_xnyn+0x493>
mov    0x30(%rsp),%rax
mov    (%rax,%rbp,1),%rdi
mov    (%r14,%rbp,1),%rsi
mov    %rbx,%rdx
call   1080 <memcpy@plt>
mov    0x8(%rsp),%rax
cmpl   $0x2,0x38(%rsp)
jl     16ae <mic_xnyn+0x52e>
mov    %r15,0x70(%rsp)
mov    0x50(%rsp),%rcx
lea    0x0(,%rcx,8),%rbp
cltq
mov    0x38(%rsp),%esi
lea    (%r14,%rax,8),%rbx
mov    %rsi,0x58(%rsp)
lea    0x0(,%rsi,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %r13d,%r13d
mov    0x18(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    (%r15,%r13,1),%rdi
mov    (%rbx,%r13,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r15,%r13,1),%rdi
mov    0x8(%rbx,%r13,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
add    $0x10,%r13
cmp    %r13,(%rsp)
jne    1660 <mic_xnyn+0x4e0>
testb  $0x1,0x58(%rsp)
mov    0x70(%rsp),%r15
je     16ae <mic_xnyn+0x52e>
mov    0x18(%rsp),%rax
mov    (%rax,%r13,1),%rdi
mov    0x0(%r13,%rbx,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    %r14,%rdi
mov    0x2c(%rsp),%esi
mov    0x60(%rsp),%rbp
mov    %ebp,%edx
xor    %ecx,%ecx
mov    0x8(%rsp),%r8
mov    0x48(%rsp),%rbx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xe0(%rsp)
push   0x18(%rsp)
push   0x50(%rsp)
mov    0x128(%rsp),%r13
push   %r13
call   1040 <make_box2ind@plt>
mov    0x28(%rsp),%rsi
add    $0x20,%rsp
cmp    $0x1,%esi
jne    1735 <mic_xnyn+0x5b5>
mov    0xf0(%rsp),%rax
movsd  (%rax),%xmm0
mov    (%r14),%rdi
mov    %ebp,%esi
movsd  %xmm0,0x138(%rsp)
mov    0x24(%rsp),%edx
mov    0xb8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1767 <mic_xnyn+0x5e7>
lea    -0x1(%rsi),%r8d
mov    0x30(%rsp),%rdi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xc0(%rsp)
push   0x88(%rsp)
push   0xe0(%rsp)
push   %r13
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    0x38(%rsp),%rsi
cmp    $0x1,%esi
jne    17b4 <mic_xnyn+0x634>
movslq 0x8(%rsp),%rax
mov    0xf0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    (%r14,%rax,8),%rdi
mov    %ebp,%esi
movsd  %xmm0,0x130(%rsp)
mov    0x24(%rsp),%edx
mov    0xa8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0x98(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    17e6 <mic_xnyn+0x666>
lea    -0x1(%rsi),%r8d
mov    0x18(%rsp),%rdi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xa0(%rsp)
push   0x80(%rsp)
push   0xd8(%rsp)
push   %r13
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
test   %ebp,%ebp
mov    0x88(%rsp),%r10
movsd  0xd8(%rsp),%xmm1
jle    1cef <mic_xnyn+0xb6f>
mov    0x8(%rsp),%rcx
movslq %ecx,%rax
mov    %rax,0x70(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xec(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0xe8(%rsp)
mov    %ebp,%eax
mov    %rax,0x158(%rsp)
mov    0x2c(%rsp),%eax
mov    %eax,%edx
mov    %ecx,%ecx
mov    %rcx,0x150(%rsp)
mov    0x28(%rsp),%ecx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x140(%rsp)
lea    -0x1(%rcx),%r13
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x148(%rsp)
mov    %eax,%edi
and    $0x3,%edi
and    $0xfffffffc,%eax
mov    %rax,0x128(%rsp)
mov    %r13,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
xorpd  %xmm2,%xmm2
xor    %ebp,%ebp
mov    %rdi,0x100(%rsp)
jmp    1943 <mic_xnyn+0x7c3>
nopl   0x0(%rax)
mov    (%r14),%rdi
mov    0x40(%rsp),%rax
mov    (%rsp),%rbp
mov    (%rax,%rbp,4),%esi
movsd  0x138(%rsp),%xmm0
mov    0x24(%rsp),%edx
movsd  0x58(%rsp),%xmm1
mov    0xb8(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    0x28(%rsp),%esi
mov    0x88(%rsp),%r10
movsd  0xd8(%rsp),%xmm1
movsd  0x60(%rsp),%xmm2
mov    0x100(%rsp),%rdi
movapd 0xf0(%rsp),%xmm0
movapd 0x110(%rsp),%xmm3
xor    %ecx,%ecx
xor    %edx,%edx
ucomisd %xmm0,%xmm3
setbe  %cl
seta   %dl
add    %edx,%esi
add    %eax,%ecx
movslq %ecx,%rax
mov    0x108(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movslq %esi,%rax
addsd  (%rcx,%rax,8),%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rbp
cmp    0x158(%rsp),%rbp
je     1cf3 <mic_xnyn+0xb73>
mov    0x40(%rsp),%rax
movslq (%rax,%rbp,4),%r8
cmpl   $0x0,0x2c(%rsp)
jle    19f8 <mic_xnyn+0x878>
cmpq   $0x3,0x140(%rsp)
jae    1970 <mic_xnyn+0x7f0>
xor    %eax,%eax
jmp    19cf <mic_xnyn+0x84f>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x128(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
mov    0x8(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
mov    0x10(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
mov    0x18(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1980 <mic_xnyn+0x800>
test   %rdi,%rdi
je     19f8 <mic_xnyn+0x878>
lea    (%r15,%rax,8),%rcx
lea    (%r14,%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,%rdi
jne    19e0 <mic_xnyn+0x860>
mov    %rbp,(%rsp)
movsd  %xmm2,0x60(%rsp)
mov    %r14,%rdi
mov    0x2c(%rsp),%esi
xor    %edx,%edx
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
mov    0x48(%rsp),%r9
movsd  0x68(%rsp),%xmm0
mov    $0x1,%al
push   %r12
push   0xe8(%rsp)
push   0x20(%rsp)
push   %r10
call   1060 <neiK@plt>
movapd 0x5d5(%rip),%xmm3
mov    0xa8(%rsp),%rdi
add    $0x20,%rsp
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
test   %ebp,%ebp
mov    0x38(%rsp),%r8
mov    0x160(%rsp),%r9
mov    0x150(%rsp),%rbp
mov    0x148(%rsp),%r10
movapd 0x59a(%rip),%xmm2
jle    1b20 <mic_xnyn+0x9a0>
xorpd  %xmm5,%xmm5
xor    %eax,%eax
jmp    1a9d <mic_xnyn+0x91d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rbp,%rax
je     1b20 <mic_xnyn+0x9a0>
test   %edi,%edi
jle    1a90 <mic_xnyn+0x910>
movsd  (%r15,%rax,8),%xmm0
mov    (%r14,%rax,8),%rcx
mov    $0x1,%edx
test   %r10,%r10
je     1afd <mic_xnyn+0x97d>
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%r12,%rdx,4),%rsi
movapd %xmm0,%xmm1
subsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm3,%xmm1
maxsd  %xmm5,%xmm1
movslq 0x4(%r12,%rdx,4),%rsi
movapd %xmm0,%xmm5
subsd  (%rcx,%rsi,8),%xmm5
andpd  %xmm3,%xmm5
maxsd  %xmm1,%xmm5
lea    (%rbx,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1ac0 <mic_xnyn+0x940>
test   $0x1,%r13b
je     1a90 <mic_xnyn+0x910>
movslq (%r12,%rdx,4),%rdx
subsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm2,%xmm0
maxsd  %xmm5,%xmm0
movapd %xmm0,%xmm5
jmp    1a90 <mic_xnyn+0x910>
nopl   (%rax)
test   %r8d,%r8d
mov    (%rsp),%rbp
jle    1bd0 <mic_xnyn+0xa50>
xorpd  %xmm4,%xmm4
mov    0x70(%rsp),%rax
jmp    1b4d <mic_xnyn+0x9cd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r9,%rax
jge    1bd0 <mic_xnyn+0xa50>
test   %edi,%edi
jle    1b40 <mic_xnyn+0x9c0>
movsd  (%r15,%rax,8),%xmm0
mov    (%r14,%rax,8),%rcx
mov    $0x1,%edx
test   %r10,%r10
je     1bad <mic_xnyn+0xa2d>
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%r12,%rdx,4),%rsi
movapd %xmm0,%xmm1
subsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm3,%xmm1
maxsd  %xmm4,%xmm1
movslq 0x4(%r12,%rdx,4),%rsi
movapd %xmm0,%xmm4
subsd  (%rcx,%rsi,8),%xmm4
andpd  %xmm3,%xmm4
maxsd  %xmm1,%xmm4
lea    (%rbx,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1b70 <mic_xnyn+0x9f0>
test   $0x1,%r13b
je     1b40 <mic_xnyn+0x9c0>
movslq (%r12,%rdx,4),%rdx
subsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm2,%xmm0
maxsd  %xmm4,%xmm0
movapd %xmm0,%xmm4
jmp    1b40 <mic_xnyn+0x9c0>
nopl   (%rax)
movapd %xmm5,%xmm1
maxsd  %xmm4,%xmm1
cmp    $0x2,%r8d
movapd %xmm4,0xf0(%rsp)
movapd %xmm5,0x110(%rsp)
movsd  %xmm1,0x58(%rsp)
jl     1c50 <mic_xnyn+0xad0>
mov    0xc8(%rsp),%rax
mov    (%rax,%rbp,4),%esi
mov    0x18(%rsp),%rdi
xor    %edx,%edx
mov    0xec(%rsp),%ecx
mov    0x48(%rsp),%rbp
mov    %ebp,%r9d
movsd  0x68(%rsp),%xmm0
mov    $0x2,%al
push   0xa0(%rsp)
push   0x80(%rsp)
call   1070 <neiE@plt>
mov    %rbp,%r9
add    $0x10,%rsp
mov    %eax,%ecx
mov    0x8(%rsp),%r8
jmp    1c96 <mic_xnyn+0xb16>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x70(%rsp),%rax
mov    (%r14,%rax,8),%rdi
mov    0x40(%rsp),%rax
mov    (%rax,%rbp,4),%esi
movsd  0x130(%rsp),%xmm0
mov    0x24(%rsp),%edx
mov    0xa8(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    0x98(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,%ecx
mov    0x8(%rsp),%r8
mov    0x48(%rsp),%r9
cmp    $0x2,%r8d
mov    %ecx,0x28(%rsp)
jl     1890 <mic_xnyn+0x710>
mov    0xd0(%rsp),%rax
mov    (%rsp),%rbp
mov    (%rax,%rbp,4),%esi
mov    0x30(%rsp),%rdi
xor    %edx,%edx
mov    0xe8(%rsp),%ecx
movsd  0x68(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
mov    $0x2,%al
push   0xc0(%rsp)
push   0x88(%rsp)
call   1070 <neiE@plt>
mov    0x38(%rsp),%esi
add    $0x10,%rsp
jmp    18d2 <mic_xnyn+0x752>
xorpd  %xmm2,%xmm2
divsd  %xmm1,%xmm2
mov    0x108(%rsp),%rcx
mov    0x50(%rsp),%rax
movsd  (%rcx,%rax,8),%xmm0
movslq %r10d,%rax
addsd  (%rcx,%rax,8),%xmm0
subsd  %xmm2,%xmm0
mov    0x120(%rsp),%rax
movsd  %xmm0,(%rax)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0x90(%rsp),%r15
mov    0x10(%rsp),%rbp
nopl   (%rax)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1d50 <mic_xnyn+0xbd0>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    0xc8(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x1,0x8(%rsp)
mov    0x30(%rsp),%r14
mov    0x80(%rsp),%rbp
mov    0x78(%rsp),%r12
jne    1dc4 <mic_xnyn+0xc44>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
jmp    1e22 <mic_xnyn+0xca2>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1dd0 <mic_xnyn+0xc50>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
jle    1e22 <mic_xnyn+0xca2>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1e10 <mic_xnyn+0xc90>
mov    %r14,%rdi
call   1030 <free@plt>
cmpl   $0x1,0x38(%rsp)
jne    1e52 <mic_xnyn+0xcd2>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%r14
jmp    1eb2 <mic_xnyn+0xd32>
xor    %ebx,%ebx
mov    0x18(%rsp),%r14
nopl   0x0(%rax)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1e60 <mic_xnyn+0xce0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rax
test   %eax,%eax
jle    1eb2 <mic_xnyn+0xd32>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1ea0 <mic_xnyn+0xd20>
mov    %r14,%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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