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


x86 assembly (clang, -O0):
<mi_xnyn>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x168,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x148(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1219 <mi_xnyn+0x99>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm2
movsd  0x1e1d(%rip),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x148(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cd <mi_xnyn+0x4d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x1,-0xb0(%rbp)
cvtsi2sdl -0xb0(%rbp),%xmm0
ff
movsd  0x1d9e(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0xb0(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    129e <mi_xnyn+0x11e>
mov    -0xb0(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    1252 <mi_xnyn+0xd2>
cvtsi2sdl -0xb0(%rbp),%xmm1
ff
movsd  0x1d5a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xb0(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x13c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0xb4(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    13bd <mi_xnyn+0x23d>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1347 <mi_xnyn+0x1c7>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1302 <mi_xnyn+0x182>
movslq -0xb0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    13a4 <mi_xnyn+0x224>
movslq -0xb0(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xd0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1365 <mi_xnyn+0x1e5>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe8(%rbp)
jmp    1409 <mi_xnyn+0x289>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x108(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x110(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    14ec <mi_xnyn+0x36c>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1476 <mi_xnyn+0x2f6>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x90(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1431 <mi_xnyn+0x2b1>
movslq -0xb0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    14d3 <mi_xnyn+0x353>
movslq -0xb0(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xc8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1494 <mi_xnyn+0x314>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe0(%rbp)
jmp    1538 <mi_xnyn+0x3b8>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf8(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x100(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x118(%rbp)
movslq -0xb0(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1595 <mi_xnyn+0x415>
movslq -0xb0(%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    1556 <mi_xnyn+0x3d6>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x120(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x128(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x130(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    164f <mi_xnyn+0x4cf>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    164a <mi_xnyn+0x4ca>
mov    -0x88(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x3,%rdx
call   1080 <memcpy@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15f9 <mi_xnyn+0x479>
jmp    164f <mi_xnyn+0x4cf>
cmpl   $0x1,-0x18(%rbp)
jle    16be <mi_xnyn+0x53e>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16b9 <mi_xnyn+0x539>
mov    -0x90(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0xac(%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    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1663 <mi_xnyn+0x4e3>
jmp    16be <mi_xnyn+0x53e>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    -0xb0(%rbp),%r9d
mov    -0x13c(%rbp),%ebx
mov    -0x120(%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,-0x14(%rbp)
jne    175f <mi_xnyn+0x5df>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
mov    -0xf0(%rbp),%rcx
mov    -0x108(%rbp),%r8
mov    -0x110(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    17b1 <mi_xnyn+0x631>
mov    -0x88(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xb0(%rbp),%r9d
mov    -0x13c(%rbp),%ebx
mov    -0x128(%rbp),%r11
mov    -0xd0(%rbp),%r10
mov    -0xe8(%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    180e <mi_xnyn+0x68e>
mov    0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
mov    -0xf8(%rbp),%rcx
mov    -0x100(%rbp),%r8
mov    -0x118(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1860 <mi_xnyn+0x6e0>
mov    -0x90(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%r8d
sub    $0x1,%r8d
mov    -0xb0(%rbp),%r9d
mov    -0x13c(%rbp),%ebx
mov    -0x130(%rbp),%r11
mov    -0xc8(%rbp),%r10
mov    -0xe0(%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,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1e2d <mi_xnyn+0xcad>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    18e8 <mi_xnyn+0x768>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x120(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    188d <mi_xnyn+0x70d>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    -0xb0(%rbp),%r9d
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x20(%rbp),%ebx
mov    -0xc0(%rbp),%r11
mov    -0xd8(%rbp),%r10
mov    -0xa8(%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,-0x60(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19fe <mi_xnyn+0x87e>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     19e5 <mi_xnyn+0x865>
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xa8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x166c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
ucomisd -0x60(%rbp),%xmm0
jbe    19d2 <mi_xnyn+0x852>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    19d7 <mi_xnyn+0x857>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    196e <mi_xnyn+0x7ee>
jmp    19ea <mi_xnyn+0x86a>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1958 <mi_xnyn+0x7d8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1aba <mi_xnyn+0x93a>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1aa1 <mi_xnyn+0x921>
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xa8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x15b0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
ucomisd -0x68(%rbp),%xmm0
jbe    1a8e <mi_xnyn+0x90e>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1a93 <mi_xnyn+0x913>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a2a <mi_xnyn+0x8aa>
jmp    1aa6 <mi_xnyn+0x926>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1a0f <mi_xnyn+0x88f>
cmpl   $0x1,-0x14(%rbp)
jle    1b1f <mi_xnyn+0x99f>
mov    -0x88(%rbp),%rdi
mov    -0x128(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0xb0(%rbp),%r9d
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
mov    -0xd0(%rbp),%r10
mov    -0xe8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x3c(%rbp)
jmp    1b66 <mi_xnyn+0x9e6>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
movsd  -0x60(%rbp),%xmm1
mov    -0xf0(%rbp),%rcx
mov    -0x108(%rbp),%r8
mov    -0x110(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    1bcb <mi_xnyn+0xa4b>
mov    -0x90(%rbp),%rdi
mov    -0x130(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0xb0(%rbp),%r9d
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
mov    -0xc8(%rbp),%r10
mov    -0xe0(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x40(%rbp)
jmp    1c17 <mi_xnyn+0xa97>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
movsd  -0x68(%rbp),%xmm1
mov    -0xf8(%rbp),%rcx
mov    -0x100(%rbp),%r8
mov    -0x118(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1d16 <mi_xnyn+0xb96>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    1c9c <mi_xnyn+0xb1c>
mov    -0x90(%rbp),%rdi
mov    -0x130(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0xb0(%rbp),%r9d
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mov    -0xc8(%rbp),%r10
mov    -0xe0(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x38(%rbp)
jmp    1ce8 <mi_xnyn+0xb68>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
movsd  -0x70(%rbp),%xmm1
mov    -0xf8(%rbp),%rcx
mov    -0x100(%rbp),%r8
mov    -0x118(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x38(%rbp)
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  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1dfb <mi_xnyn+0xc7b>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    1d8b <mi_xnyn+0xc0b>
mov    -0x88(%rbp),%rdi
mov    -0x128(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0xb0(%rbp),%r9d
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
mov    -0xd0(%rbp),%r10
mov    -0xe8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x34(%rbp)
jmp    1dd2 <mi_xnyn+0xc52>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x120(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x98(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%edx
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rcx
mov    -0x108(%rbp),%r8
mov    -0x110(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x34(%rbp)
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  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1877 <mi_xnyn+0x6f7>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%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  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x148(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1efd <mi_xnyn+0xd7d>
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    1ecc <mi_xnyn+0xd4c>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x120(%rbp),%rdi
call   1030 <free@plt>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x14(%rbp)
jne    1f60 <mi_xnyn+0xde0>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
jmp    2000 <mi_xnyn+0xe80>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    1f98 <mi_xnyn+0xe18>
mov    -0xd0(%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    1f67 <mi_xnyn+0xde7>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ff4 <mi_xnyn+0xe74>
mov    -0x88(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1fba <mi_xnyn+0xe3a>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x18(%rbp)
jne    2033 <mi_xnyn+0xeb3>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
jmp    20d3 <mi_xnyn+0xf53>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jge    206b <mi_xnyn+0xeeb>
mov    -0xc8(%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    203a <mi_xnyn+0xeba>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    20c7 <mi_xnyn+0xf47>
mov    -0x90(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    208d <mi_xnyn+0xf0d>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x148(%rbp),%rdi
call   1030 <free@plt>
add    $0x168,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mi_xnyn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,%rbx
mov    %r8d,%r12d
mov    %rcx,0x70(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x38(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0x1d8(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0x90(%rsp)
lea    0x1(%r12),%r13d
movslq %r13d,%r14
lea    0x0(,%r14,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    %r12,0x98(%rsp)
test   %r12d,%r12d
jle    1323 <mi_xnyn+0x1a3>
mov    %r13d,%eax
lea    -0x1(%rax),%rcx
mov    $0x1,%edx
cmp    $0x2,%rcx
jb     12f8 <mi_xnyn+0x178>
mov    %rcx,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2243 <mi_xnyn+0x10c3>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0x1db9(%rip),%xmm0
xor    %esi,%esi
movapd 0x1dbf(%rip),%xmm1
movdqa 0x1dc7(%rip),%xmm2
movdqa 0x1dcf(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rbx,%rsi,8),%xmm4
cvtdq2pd %xmm0,%xmm5
movapd %xmm1,%xmm6
divpd  %xmm5,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,0x8(%r15,%rsi,8)
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movupd 0x18(%rbx,%rsi,8),%xmm5
cvtdq2pd %xmm4,%xmm4
movapd %xmm1,%xmm6
divpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x18(%r15,%rsi,8)
add    $0x4,%rsi
paddd  %xmm3,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    1270 <mi_xnyn+0xf0>
test   $0x1,%dl
je     12ec <mi_xnyn+0x16c>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd (%rbx,%rsi,1),%xmm1
cvtdq2pd %xmm0,%xmm0
movapd 0x1d62(%rip),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rsi,1)
cmp    %r8,%rcx
je     1323 <mi_xnyn+0x1a3>
or     $0x1,%rcx
mov    %rcx,%rdx
movsd  0x1d60(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
addsd  (%rbx,%rdx,8),%xmm2
movsd  %xmm2,(%r15,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1300 <mi_xnyn+0x180>
mov    %r13d,0x140(%rsp)
mov    %rbx,0x110(%rsp)
shl    $0x2,%r14
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,%r12
mov    0x18(%rsp),%rax
mov    0x8(%rsp),%rcx
add    %ecx,%eax
mov    %eax,0x58(%rsp)
cltq
mov    %rax,0x190(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r13
xorps  %xmm0,%xmm0
cvtsi2sdl 0x98(%rsp),%xmm0
mov    0x70(%rsp),%rdx
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
mov    $0x1,%eax
movsd  0x1cd7(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    (%rcx,%rcx,1),%eax
ucomisd %xmm2,%xmm3
ja     13a0 <mi_xnyn+0x220>
movsd  %xmm4,(%rsp)
mov    %rcx,0x30(%rsp)
movsd  %xmm3,0x108(%rsp)
movslq %edx,%rbx
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
mov    %r15,0x160(%rsp)
mov    %rbx,0x60(%rsp)
jl     1499 <mi_xnyn+0x319>
mov    %eax,%ebp
lea    0x0(,%rbp,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r15
lea    0x0(,%rbx,8),%r14
xor    %ebx,%ebx
nop
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1410 <mi_xnyn+0x290>
mov    %r15,0x28(%rsp)
mov    0x30(%rsp),%rbx
mov    %ebx,%ebp
lea    0x0(,%rbp,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r14
shl    $0x2,%rbp
cmp    $0x2,%ebx
mov    $0x1,%r15d
cmovae %ebx,%r15d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1460 <mi_xnyn+0x2e0>
mov    %r14,0xd0(%rsp)
mov    0x60(%rsp),%rbx
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0xc0(%rsp)
jmp    14d3 <mi_xnyn+0x353>
lea    -0x10(,%rbx,4),%r14
ff
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb8(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb0(%rsp)
movsd  0x1b95(%rip),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    0x18(%rsp),%rax
cmp    $0x2,%eax
jl     15ab <mi_xnyn+0x42b>
mov    %eax,%ebp
lea    0x0(,%rbp,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r15
lea    0x0(,%rbx,8),%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1510 <mi_xnyn+0x390>
mov    %r15,0x20(%rsp)
mov    0x30(%rsp),%rbx
mov    %ebx,%ebp
lea    0x0(,%rbp,8),%r14
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x88(%rsp)
shl    $0x2,%rbp
cmp    $0x2,%ebx
mov    $0x1,%r15d
cmovae %ebx,%r15d
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %rbp,%rdi
call   10a0 <malloc@plt>
mov    0x88(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1560 <mi_xnyn+0x3e0>
mov    %r15,0xf8(%rsp)
mov    0x60(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    0x20(%rsp),%rbx
mov    0x30(%rsp),%rax
jmp    1609 <mi_xnyn+0x489>
lea    -0x10(,%rbx,4),%r14
ff
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x100(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xa8(%rsp)
mov    0x30(%rsp),%rax
mov    %eax,%ebp
lea    0x0(,%rbp,8),%r14
shl    $0x2,%rbp
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovae %eax,%ecx
mov    %rcx,0xf8(%rsp)
mov    %rbx,0x20(%rsp)
movsd  0x40(%rsp),%xmm0
divsd  (%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
shr    $0x2,%eax
mov    %rax,0x68(%rsp)
mov    0x70(%rsp),%rax
add    $0xfffffffb,%eax
mov    %eax,0x14(%rsp)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,%r14
xor    %ebx,%ebx
mov    0xf8(%rsp),%r15
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1650 <mi_xnyn+0x4d0>
mov    %r14,0x120(%rsp)
mov    0x60(%rsp),%rax
lea    0x0(,%rax,4),%r14
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x118(%rsp)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %r14,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xd8(%rsp)
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
jl     1758 <mi_xnyn+0x5d8>
mov    0x60(%rsp),%rcx
lea    0x0(,%rcx,8),%r14
mov    %eax,%eax
mov    %rax,0x48(%rsp)
lea    0x0(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %ebx,%ebx
mov    0x28(%rsp),%r15
mov    0x38(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rbx,1),%rdi
mov    0x0(%rbp,%rbx,1),%rsi
mov    %r14,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r15,%rbx,1),%rdi
mov    0x8(%rbp,%rbx,1),%rsi
mov    %r14,%rdx
call   1080 <memcpy@plt>
add    $0x10,%rbx
cmp    %rbx,(%rsp)
jne    1700 <mi_xnyn+0x580>
testb  $0x1,0x48(%rsp)
mov    0x8(%rsp),%rax
je     1758 <mi_xnyn+0x5d8>
mov    0x28(%rsp),%rax
mov    (%rax,%rbx,1),%rdi
mov    0x38(%rsp),%rax
mov    (%rax,%rbx,1),%rsi
mov    %r14,%rdx
call   1080 <memcpy@plt>
mov    0x8(%rsp),%rax
cmpl   $0x2,0x18(%rsp)
jl     17e8 <mi_xnyn+0x668>
mov    0x60(%rsp),%rcx
lea    0x0(,%rcx,8),%rbp
cltq
mov    0x18(%rsp),%edx
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
mov    %rdx,0x48(%rsp)
lea    0x0(,%rdx,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %r15d,%r15d
mov    0x20(%rsp),%r14
nopl   0x0(%rax)
mov    (%r14,%r15,1),%rdi
mov    (%rbx,%r15,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r14,%r15,1),%rdi
mov    0x8(%rbx,%r15,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
add    $0x10,%r15
cmp    %r15,(%rsp)
jne    17a0 <mi_xnyn+0x620>
testb  $0x1,0x48(%rsp)
je     17e8 <mi_xnyn+0x668>
mov    0x20(%rsp),%rax
mov    (%rax,%r15,1),%rdi
mov    (%r15,%rbx,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x38(%rsp),%rbx
mov    %rbx,%rdi
mov    0x58(%rsp),%r15d
mov    %r15d,%esi
mov    0x70(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%r8
mov    0x30(%rsp),%rbp
mov    %ebp,%r9d
xor    %eax,%eax
push   0x118(%rsp)
push   0x128(%rsp)
mov    0x60(%rsp),%r14
push   %r14
push   0x80(%rsp)
call   1040 <make_box2ind@plt>
mov    0x28(%rsp),%rsi
add    $0x20,%rsp
cmp    $0x1,%esi
jne    1886 <mi_xnyn+0x706>
mov    0x90(%rsp),%rax
movsd  (%rax),%xmm0
mov    (%rbx),%rdi
mov    0x70(%rsp),%rsi
movsd  %xmm0,0x128(%rsp)
mov    0x14(%rsp),%edx
mov    0xb8(%rsp),%rcx
mov    0x28(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
mov    0x20(%rsp),%rbx
mov    0x68(%rsp),%rbp
jmp    18c7 <mi_xnyn+0x747>
lea    -0x1(%rsi),%r8d
mov    0x28(%rsp),%rdi
mov    0x70(%rsp),%rdx
xor    %ecx,%ecx
mov    %ebp,%r9d
xor    %eax,%eax
push   0xc0(%rsp)
push   0xd8(%rsp)
push   0xf0(%rsp)
mov    0x80(%rsp),%rbp
push   %rbp
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%rsi
cmp    $0x1,%esi
jne    191d <mi_xnyn+0x79d>
movslq 0x8(%rsp),%rax
mov    0x90(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x38(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mov    0x70(%rsp),%rsi
movsd  %xmm0,0xe8(%rsp)
mov    0x14(%rsp),%edx
mov    0x100(%rsp),%rcx
mov    %rbx,%r8
mov    %rsi,%rbx
mov    0xa8(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1953 <mi_xnyn+0x7d3>
lea    -0x1(%rsi),%r8d
mov    %rbx,%rdi
mov    0x70(%rsp),%rbx
mov    %ebx,%edx
xor    %ecx,%ecx
mov    0x30(%rsp),%r9
xor    %eax,%eax
push   0xc8(%rsp)
push   0x90(%rsp)
push   0xe8(%rsp)
push   %rbp
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
test   %ebx,%ebx
mov    0x98(%rsp),%r10
movsd  0x108(%rsp),%xmm3
jle    202f <mi_xnyn+0xeaf>
mov    0x8(%rsp),%rcx
movslq %ecx,%rax
mov    %rax,0xf0(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0xa0(%rsp)
mov    0x18(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xa4(%rsp)
mov    %ebx,%eax
mov    %rax,0x188(%rsp)
mov    %r15d,%eax
mov    %ecx,%ecx
mov    %rcx,0x180(%rsp)
mov    0x140(%rsp),%ecx
add    $0xffffffffffffffff,%rax
mov    %rax,0x168(%rsp)
lea    -0x1(%rcx),%r11
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x178(%rsp)
mov    %r15d,%edi
and    $0x3,%edi
mov    %r15d,%ebp
and    $0xfffffffc,%ebp
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
xorpd  %xmm5,%xmm5
xor    %eax,%eax
xorpd  %xmm4,%xmm4
mov    %r11,0x170(%rsp)
mov    %rdi,0x138(%rsp)
mov    %rbp,0x130(%rsp)
jmp    1ac3 <mi_xnyn+0x943>
nopl   0x0(%rax)
mov    0x38(%rsp),%rax
mov    (%rax),%rdi
mov    (%rsp),%rax
mov    (%r14,%rax,4),%esi
movsd  0x128(%rsp),%xmm0
mov    0x14(%rsp),%edx
mov    0xb8(%rsp),%rcx
mov    0x28(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
cltq
movslq 0x5c(%rsp),%rcx
mov    0x110(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x8(%rdx,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movslq 0x48(%rsp),%rax
movsd  (%rdx,%rax,8),%xmm2
mov    0x98(%rsp),%r10
movsd  0x108(%rsp),%xmm3
movsd  0x68(%rsp),%xmm4
movsd  0x90(%rsp),%xmm5
mov    0x138(%rsp),%rdi
mov    0x130(%rsp),%rbp
mov    (%rsp),%rax
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm4
addsd  %xmm0,%xmm5
add    $0x1,%rax
cmp    0x188(%rsp),%rax
je     2037 <mi_xnyn+0xeb7>
mov    %rax,(%rsp)
movslq (%r14,%rax,4),%r8
test   %r15d,%r15d
movsd  0x40(%rsp),%xmm0
mov    0x38(%rsp),%r14
jle    1b88 <mi_xnyn+0xa08>
cmpq   $0x3,0x168(%rsp)
jae    1af0 <mi_xnyn+0x970>
xor    %eax,%eax
jmp    1b50 <mi_xnyn+0x9d0>
xchg   %ax,%ax
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
mov    0x8(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
mov    0x10(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm1
movsd  %xmm1,0x10(%r13,%rax,8)
mov    0x18(%r14,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm1
movsd  %xmm1,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1b00 <mi_xnyn+0x980>
test   %rdi,%rdi
je     1b88 <mi_xnyn+0xa08>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
lea    (%r14,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1b70 <mi_xnyn+0x9f0>
movsd  %xmm5,0x90(%rsp)
movsd  %xmm4,0x68(%rsp)
mov    %r14,%rdi
mov    %r15d,%esi
xor    %edx,%edx
mov    0x8(%rsp),%r15
mov    %r15d,%ecx
mov    0x30(%rsp),%r9
mov    $0x1,%al
push   %r12
push   0x120(%rsp)
push   0x130(%rsp)
push   %r10
call   1060 <neiK@plt>
mov    0x190(%rsp),%r11
mov    0xb8(%rsp),%rdi
add    $0x20,%rsp
xorpd  %xmm5,%xmm5
xorpd  %xmm1,%xmm1
test   %r15d,%r15d
mov    0x18(%rsp),%r8
mov    0x180(%rsp),%rbp
mov    0x178(%rsp),%r10
movapd 0x144f(%rip),%xmm3
movapd 0x1447(%rip),%xmm4
jle    1cb0 <mi_xnyn+0xb30>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    1c2d <mi_xnyn+0xaad>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbp,%rax
je     1cb0 <mi_xnyn+0xb30>
test   %edi,%edi
jle    1c20 <mi_xnyn+0xaa0>
movsd  0x0(%r13,%rax,8),%xmm0
mov    (%r14,%rax,8),%rcx
mov    $0x1,%edx
test   %r10,%r10
je     1c8d <mi_xnyn+0xb0d>
cs nopw 0x0(%rax,%rax,1)
movslq (%r12,%rdx,4),%rsi
movapd %xmm0,%xmm2
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm4,%xmm2
maxsd  %xmm1,%xmm2
movslq 0x4(%r12,%rdx,4),%rsi
movapd %xmm0,%xmm1
subsd  (%rcx,%rsi,8),%xmm1
andpd  %xmm4,%xmm1
maxsd  %xmm2,%xmm1
lea    (%rbx,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1c50 <mi_xnyn+0xad0>
test   $0x1,%r11b
je     1c20 <mi_xnyn+0xaa0>
movslq (%r12,%rdx,4),%rdx
subsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm3,%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
jmp    1c20 <mi_xnyn+0xaa0>
nopl   (%rax)
mov    %r14,%r9
test   %r8d,%r8d
mov    0x190(%rsp),%r8
movsd  0x40(%rsp),%xmm0
mov    0x14(%rsp),%edx
jle    1d70 <mi_xnyn+0xbf0>
xorpd  %xmm5,%xmm5
mov    0xf0(%rsp),%rax
jmp    1ced <mi_xnyn+0xb6d>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %r8,%rax
jge    1d70 <mi_xnyn+0xbf0>
test   %edi,%edi
jle    1ce0 <mi_xnyn+0xb60>
movsd  0x0(%r13,%rax,8),%xmm2
mov    (%r9,%rax,8),%rcx
mov    $0x1,%ebp
test   %r10,%r10
je     1d4d <mi_xnyn+0xbcd>
cs nopw 0x0(%rax,%rax,1)
movslq (%r12,%rbp,4),%rsi
movapd %xmm2,%xmm6
subsd  (%rcx,%rsi,8),%xmm6
andpd  %xmm4,%xmm6
maxsd  %xmm5,%xmm6
movslq 0x4(%r12,%rbp,4),%rsi
movapd %xmm2,%xmm5
subsd  (%rcx,%rsi,8),%xmm5
andpd  %xmm4,%xmm5
maxsd  %xmm6,%xmm5
lea    (%rbx,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rbp
cmp    $0x1,%rsi
jne    1d10 <mi_xnyn+0xb90>
test   $0x1,%r11b
je     1ce0 <mi_xnyn+0xb60>
movslq (%r12,%rbp,4),%rsi
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm3,%xmm2
maxsd  %xmm5,%xmm2
movapd %xmm2,%xmm5
jmp    1ce0 <mi_xnyn+0xb60>
nopl   (%rax)
movapd %xmm5,0x70(%rsp)
cmp    $0x2,%r15d
movapd %xmm1,0x140(%rsp)
jl     1de0 <mi_xnyn+0xc60>
mov    0xe0(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x28(%rsp),%rdi
xor    %edx,%edx
mov    0xa0(%rsp),%ecx
mov    %r15d,%r8d
mov    0x30(%rsp),%r9
mov    $0x2,%al
push   0xc0(%rsp)
push   0xd8(%rsp)
call   1070 <neiE@plt>
movaps 0x80(%rsp),%xmm1
mov    0x28(%rsp),%r8
add    $0x10,%rsp
mov    %eax,0x48(%rsp)
mov    0x20(%rsp),%rbp
mov    0x50(%rsp),%r14
jmp    1e28 <mi_xnyn+0xca8>
mov    (%r9),%rdi
mov    0x50(%rsp),%r14
mov    (%rsp),%rax
mov    (%r14,%rax,4),%esi
movsd  0x128(%rsp),%xmm0
mov    0xb8(%rsp),%rcx
mov    0x28(%rsp),%r8
mov    0xb0(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
movaps 0x70(%rsp),%xmm1
mov    0x18(%rsp),%r8
mov    %eax,0x48(%rsp)
mov    0x20(%rsp),%rbp
movsd  0xe8(%rsp),%xmm0
mov    0xf0(%rsp),%rax
mov    0xa4(%rsp),%ecx
cmp    $0x2,%r8d
jl     1ef0 <mi_xnyn+0xd70>
mov    0xd8(%rsp),%rax
mov    (%rsp),%rdx
mov    (%rax,%rdx,4),%esi
mov    %rbp,%rdi
xor    %edx,%edx
mov    %ecx,%r14d
mov    0x30(%rsp),%r15
mov    %r15d,%r9d
movsd  0x40(%rsp),%xmm0
mov    $0x2,%al
push   0xc8(%rsp)
push   0x90(%rsp)
call   1070 <neiE@plt>
movapd 0x80(%rsp),%xmm1
add    $0x10,%rsp
mov    %eax,0x5c(%rsp)
movapd 0x140(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    1fd0 <mi_xnyn+0xe50>
mov    0xd8(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%esi
mov    %rbp,%rdi
xor    %edx,%edx
mov    %r14d,%ecx
mov    0x18(%rsp),%r8
mov    %r15d,%r9d
movsd  0x40(%rsp),%xmm0
movapd %xmm2,%xmm1
mov    $0x2,%al
push   0xc8(%rsp)
push   0x90(%rsp)
call   1070 <neiE@plt>
add    $0x10,%rsp
jmp    1f86 <mi_xnyn+0xe06>
nop
mov    0x38(%rsp),%r15
mov    (%r15,%rax,8),%rdi
mov    (%rsp),%rcx
mov    (%r14,%rcx,4),%esi
movsd  %xmm0,0xe8(%rsp)
mov    0x14(%rsp),%edx
mov    0x100(%rsp),%r14
mov    %r14,%rcx
mov    %rbp,%r8
mov    0xa8(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
movapd 0x70(%rsp),%xmm1
mov    %eax,0x5c(%rsp)
movapd 0x140(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    1fd0 <mi_xnyn+0xe50>
mov    0xf0(%rsp),%rax
mov    (%r15,%rax,8),%rdi
mov    (%rsp),%rax
mov    0x50(%rsp),%rcx
mov    (%rcx,%rax,4),%esi
movsd  0xe8(%rsp),%xmm0
mov    0x14(%rsp),%edx
movapd %xmm2,%xmm1
mov    %r14,%rcx
mov    %rbp,%r8
mov    0xa8(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
movslq 0x48(%rsp),%rcx
mov    0x110(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm2
cltq
movsd  0x8(%rdx,%rax,8),%xmm0
addsd  %xmm2,%xmm0
movslq 0x5c(%rsp),%rax
movsd  (%rdx,%rax,8),%xmm1
mov    0x98(%rsp),%r10
movsd  0x108(%rsp),%xmm3
mov    0x58(%rsp),%r15d
mov    0x50(%rsp),%r14
jmp    1a82 <mi_xnyn+0x902>
xchg   %ax,%ax
movsd  0x40(%rsp),%xmm0
mov    0x8(%rsp),%r8
cmp    $0x2,%r8d
mov    0x58(%rsp),%r15d
mov    0x50(%rsp),%r14
jl     1a10 <mi_xnyn+0x890>
mov    0xe0(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x28(%rsp),%rdi
xor    %edx,%edx
mov    0xa0(%rsp),%ecx
mov    0x30(%rsp),%r9
mov    $0x2,%al
push   0xc0(%rsp)
push   0xd8(%rsp)
call   1070 <neiE@plt>
add    $0x10,%rsp
jmp    1a49 <mi_xnyn+0x8c9>
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
divsd  %xmm3,%xmm5
mov    0x110(%rsp),%rcx
mov    0x60(%rsp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq %r10d,%rax
addsd  (%rcx,%rax,8),%xmm0
subsd  %xmm5,%xmm0
mov    0x150(%rsp),%rdx
movsd  %xmm0,(%rdx)
divsd  %xmm3,%xmm4
movsd  (%rcx,%rsi,8),%xmm0
mov    0x160(%rsp),%r14
addsd  (%r14,%rax,8),%xmm0
subsd  %xmm4,%xmm0
mov    0x158(%rsp),%rax
movsd  %xmm0,(%rax)
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x118(%rsp),%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0xf8(%rsp),%r12
mov    0x120(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    20c0 <mi_xnyn+0xf40>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x1,0x8(%rsp)
mov    0x28(%rsp),%r15
mov    0xd0(%rsp),%rbp
mov    0x88(%rsp),%r13
jne    2137 <mi_xnyn+0xfb7>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
jmp    2192 <mi_xnyn+0x1012>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    2140 <mi_xnyn+0xfc0>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0xc0(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
jle    2192 <mi_xnyn+0x1012>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2180 <mi_xnyn+0x1000>
mov    %r15,%rdi
call   1030 <free@plt>
cmpl   $0x1,0x18(%rsp)
mov    0x100(%rsp),%rbx
mov    0xc8(%rsp),%rbp
jne    21cd <mi_xnyn+0x104d>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%r15
jmp    2222 <mi_xnyn+0x10a2>
xor    %ebx,%ebx
mov    0x20(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
jne    21e0 <mi_xnyn+0x1060>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    2222 <mi_xnyn+0x10a2>
mov    %eax,%ebx
xor    %ebp,%ebp
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2210 <mi_xnyn+0x1090>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
movdqa 0xdb5(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%dl
jne    12c5 <mi_xnyn+0x145>
jmp    12ec <mi_xnyn+0x16c>

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

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