void mir_xnyn(double **x, int dimx, int dimy, int N, int K, double *psi,
              double *scal, double *mir) {
  int i, k, nx2, ny2;
  double *xc, dy, dx;
  double epsx, epsy;
  double 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);
  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);
    dxy2 += psi[nx2] + psi[ny2];
  }
  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):
<mir_xnyn>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x148,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x130(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1215 <mir_xnyn+0x95>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm2
movsd  0xe21(%rip),%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x130(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c9 <mir_xnyn+0x49>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x98(%rbp)
cvtsi2sdl -0x98(%rbp),%xmm0
ff
movsd  0xda2(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x98(%rbp),%xmm0
ff
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x20(%rbp),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    129a <mir_xnyn+0x11a>
mov    -0x98(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    124e <mir_xnyn+0xce>
cvtsi2sdl -0x98(%rbp),%xmm1
ff
movsd  0xd5e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x124(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    13b3 <mir_xnyn+0x233>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    133d <mir_xnyn+0x1bd>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    12fb <mir_xnyn+0x17b>
movslq -0x98(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    139a <mir_xnyn+0x21a>
movslq -0x98(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    135b <mir_xnyn+0x1db>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xd0(%rbp)
jmp    13ff <mir_xnyn+0x27f>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%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,-0xf0(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xf8(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    14dc <mir_xnyn+0x35c>
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1466 <mir_xnyn+0x2e6>
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1424 <mir_xnyn+0x2a4>
movslq -0x98(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    14c3 <mir_xnyn+0x343>
movslq -0x98(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xb0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1484 <mir_xnyn+0x304>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc8(%rbp)
jmp    1528 <mir_xnyn+0x3a8>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xe8(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x100(%rbp)
movslq -0x98(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1585 <mir_xnyn+0x405>
movslq -0x98(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1546 <mir_xnyn+0x3c6>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x108(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x110(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x118(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    163c <mir_xnyn+0x4bc>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1637 <mir_xnyn+0x4b7>
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rdx
shl    $0x3,%rdx
call   1080 <memcpy@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    15e9 <mir_xnyn+0x469>
jmp    163c <mir_xnyn+0x4bc>
cmpl   $0x1,-0x18(%rbp)
jle    16a8 <mir_xnyn+0x528>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16a3 <mir_xnyn+0x523>
mov    -0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x94(%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    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1650 <mir_xnyn+0x4d0>
jmp    16a8 <mir_xnyn+0x528>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0x124(%rbp),%ebx
mov    -0x108(%rbp),%r11
mov    -0xa8(%rbp),%r10
mov    -0xc0(%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    1743 <mir_xnyn+0x5c3>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0x80(%rbp),%xmm0
mov    -0x9c(%rbp),%edx
mov    -0xd8(%rbp),%rcx
mov    -0xf0(%rbp),%r8
mov    -0xf8(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1792 <mir_xnyn+0x612>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x98(%rbp),%r9d
mov    -0x124(%rbp),%ebx
mov    -0x110(%rbp),%r11
mov    -0xb8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %ecx,%ecx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   1040 <make_box2ind@plt>
cmpl   $0x1,-0x18(%rbp)
jne    17ef <mir_xnyn+0x66f>
mov    0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x1c(%rbp),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x9c(%rbp),%edx
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%r8
mov    -0x100(%rbp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    183e <mir_xnyn+0x6be>
mov    -0x78(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x98(%rbp),%r9d
mov    -0x124(%rbp),%ebx
mov    -0x118(%rbp),%r11
mov    -0xb0(%rbp),%r10
mov    -0xc8(%rbp),%rax
xor    %ecx,%ecx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   1040 <make_box2ind@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1c16 <mir_xnyn+0xa96>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    18be <mir_xnyn+0x73e>
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x108(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1863 <mir_xnyn+0x6e3>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    -0x108(%rbp),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,4),%r8d
mov    -0x98(%rbp),%r9d
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%ebx
mov    -0xa8(%rbp),%r11
mov    -0xc0(%rbp),%r10
mov    -0x90(%rbp),%rax
xor    %edx,%edx
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x1,%al
call   1060 <neiK@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19d4 <mir_xnyn+0x854>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     19bb <mir_xnyn+0x83b>
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x90(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x696(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
ucomisd -0x58(%rbp),%xmm0
jbe    19a8 <mir_xnyn+0x828>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    19ad <mir_xnyn+0x82d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1944 <mir_xnyn+0x7c4>
jmp    19c0 <mir_xnyn+0x840>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    192e <mir_xnyn+0x7ae>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1a90 <mir_xnyn+0x910>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1a77 <mir_xnyn+0x8f7>
mov    -0x40(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x90(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x5da(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
ucomisd -0x60(%rbp),%xmm0
jbe    1a64 <mir_xnyn+0x8e4>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1a69 <mir_xnyn+0x8e9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a00 <mir_xnyn+0x880>
jmp    1a7c <mir_xnyn+0x8fc>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    19e5 <mir_xnyn+0x865>
cmpl   $0x1,-0x14(%rbp)
jle    1af2 <mir_xnyn+0x972>
mov    -0x70(%rbp),%rdi
mov    -0x110(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x14(%rbp),%r8d
mov    -0x98(%rbp),%r9d
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm1
mov    -0xb8(%rbp),%r10
mov    -0xd0(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x34(%rbp)
jmp    1b36 <mir_xnyn+0x9b6>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x108(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x80(%rbp),%xmm0
mov    -0x9c(%rbp),%edx
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rcx
mov    -0xf0(%rbp),%r8
mov    -0xf8(%rbp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    1b98 <mir_xnyn+0xa18>
mov    -0x78(%rbp),%rdi
mov    -0x118(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%r8d
mov    -0x98(%rbp),%r9d
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
mov    -0xb0(%rbp),%r10
mov    -0xc8(%rbp),%rax
xor    %edx,%edx
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x2,%al
call   1070 <neiE@plt>
mov    %eax,-0x38(%rbp)
jmp    1be4 <mir_xnyn+0xa64>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x108(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x9c(%rbp),%edx
movsd  -0x60(%rbp),%xmm1
mov    -0xe0(%rbp),%rcx
mov    -0xe8(%rbp),%r8
mov    -0x100(%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
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    184d <mir_xnyn+0x6cd>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x130(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1cac <mir_xnyn+0xb2c>
mov    -0xa8(%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    1c7b <mir_xnyn+0xafb>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
mov    -0x110(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x14(%rbp)
jne    1d0f <mir_xnyn+0xb8f>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
jmp    1da9 <mir_xnyn+0xc29>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1d47 <mir_xnyn+0xbc7>
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d16 <mir_xnyn+0xb96>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1da0 <mir_xnyn+0xc20>
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1d69 <mir_xnyn+0xbe9>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1ddc <mir_xnyn+0xc5c>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
jmp    1e76 <mir_xnyn+0xcf6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1e14 <mir_xnyn+0xc94>
mov    -0xb0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1de3 <mir_xnyn+0xc63>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1e6d <mir_xnyn+0xced>
mov    -0x78(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1e36 <mir_xnyn+0xcb6>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x130(%rbp),%rdi
call   1030 <free@plt>
add    $0x148,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mir_xnyn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,%r15
mov    %r8d,%r12d
mov    %rcx,0x38(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x10(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0x100(%rsp)
lea    0x1(%r12),%ebp
movslq %ebp,%r14
lea    0x0(,%r14,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r12,0x80(%rsp)
test   %r12d,%r12d
jle    1303 <mir_xnyn+0x183>
mov    %ebp,%eax
lea    -0x1(%rax),%rcx
mov    $0x1,%edx
cmp    $0x2,%rcx
jb     12d8 <mir_xnyn+0x158>
mov    %rcx,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2043 <mir_xnyn+0xec3>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0x1dca(%rip),%xmm0
xor    %esi,%esi
movapd 0x1dd0(%rip),%xmm1
movdqa 0x1dd8(%rip),%xmm2
movdqa 0x1de0(%rip),%xmm3
movupd 0x8(%r15,%rsi,8),%xmm4
cvtdq2pd %xmm0,%xmm5
movapd %xmm1,%xmm6
divpd  %xmm5,%xmm6
subpd  %xmm6,%xmm4
movupd %xmm4,0x8(%rbx,%rsi,8)
movdqa %xmm0,%xmm4
paddd  %xmm2,%xmm4
movupd 0x18(%r15,%rsi,8),%xmm5
cvtdq2pd %xmm4,%xmm4
movapd %xmm1,%xmm6
divpd  %xmm4,%xmm6
subpd  %xmm6,%xmm5
movupd %xmm5,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
paddd  %xmm3,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    1250 <mir_xnyn+0xd0>
test   $0x1,%dl
je     12cc <mir_xnyn+0x14c>
shl    $0x3,%rsi
or     $0x8,%rsi
movupd (%r15,%rsi,1),%xmm1
cvtdq2pd %xmm0,%xmm0
movapd 0x1d81(%rip),%xmm2
divpd  %xmm0,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rsi,1)
cmp    %r8,%rcx
je     1303 <mir_xnyn+0x183>
or     $0x1,%rcx
mov    %rcx,%rdx
movsd  0x1d80(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm0,%xmm2
divsd  %xmm1,%xmm2
addsd  (%r15,%rdx,8),%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12e0 <mir_xnyn+0x160>
mov    %ebp,0xd8(%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,0x2c(%rsp)
cltq
mov    %rax,0x160(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r13
xorps  %xmm0,%xmm0
cvtsi2sdl 0x80(%rsp),%xmm0
mov    0x38(%rsp),%r14
xorps  %xmm3,%xmm3
cvtsi2sd %r14d,%xmm3
mov    $0x1,%eax
movsd  0x1cff(%rip),%xmm1
nopl   0x0(%rax)
mov    %eax,%ebp
xorps  %xmm4,%xmm4
cvtsi2sd %eax,%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm2
mulsd  %xmm0,%xmm2
lea    0x0(%rbp,%rbp,1),%eax
ucomisd %xmm2,%xmm3
ja     1370 <mir_xnyn+0x1f0>
movsd  %xmm4,0x40(%rsp)
movsd  %xmm3,0xe0(%rsp)
mov    %r15,0x88(%rsp)
mov    %rbx,0x128(%rsp)
movslq %r14d,%rbx
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
mov    %rbp,0x58(%rsp)
mov    %rbx,0x48(%rsp)
jl     1484 <mir_xnyn+0x304>
mov    %eax,%eax
mov    %rax,(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbx,8),%r15
xor    %ebx,%ebx
nopl   (%rax)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,(%rsp)
jne    13f0 <mir_xnyn+0x270>
mov    %r14,0x30(%rsp)
mov    %ebp,%r15d
lea    0x0(,%r15,8),%rdi
call   10a0 <malloc@plt>
mov    %rbp,%rcx
mov    %rax,%rbp
shl    $0x2,%r15
cmp    $0x2,%ecx
mov    $0x1,%r14d
cmovae %ecx,%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1440 <mir_xnyn+0x2c0>
mov    %rbp,0xc0(%rsp)
mov    0x48(%rsp),%rbx
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb8(%rsp)
mov    0x58(%rsp),%rbp
mov    0x38(%rsp),%r14
jmp    14be <mir_xnyn+0x33e>
lea    -0x10(,%rbx,4),%r15
ff
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xb0(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xa8(%rsp)
movsd  0x1baa(%rip),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x18(%rsp),%rax
cmp    $0x2,%eax
jl     1594 <mir_xnyn+0x414>
mov    %eax,%eax
mov    %rax,(%rsp)
lea    0x0(,%rax,8),%rdi
call   10a0 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbx,8),%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,(%rsp)
jne    1500 <mir_xnyn+0x380>
mov    %r14,0x20(%rsp)
mov    %ebp,%r15d
lea    0x0(,%r15,8),%rdi
mov    %rdi,(%rsp)
call   10a0 <malloc@plt>
mov    %rax,0x68(%rsp)
shl    $0x2,%r15
cmp    $0x2,%ebp
mov    $0x1,%r14d
cmovae %ebp,%r14d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    0x68(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1550 <mir_xnyn+0x3d0>
mov    %r14,0x60(%rsp)
mov    0x48(%rsp),%rax
lea    0x0(,%rax,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    0x38(%rsp),%r14
mov    (%rsp),%rdi
jmp    15ed <mir_xnyn+0x46d>
lea    -0x10(,%rbx,4),%r15
ff
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xa0(%rsp)
lea    0x0(,%rbx,4),%rdi
call   10a0 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    %ebp,%r15d
lea    0x0(,%r15,8),%rdi
shl    $0x2,%r15
cmp    $0x2,%ebp
mov    $0x1,%eax
cmovae %ebp,%eax
mov    %rax,0x60(%rsp)
movsd  0x78(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
shr    $0x2,%ebp
mov    %rbp,0x70(%rsp)
lea    -0x5(%r14),%eax
mov    %eax,0x28(%rsp)
call   10a0 <malloc@plt>
mov    %rax,%r14
xor    %ebx,%ebx
mov    0x60(%rsp),%rbp
xchg   %ax,%ax
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1620 <mir_xnyn+0x4a0>
mov    %r14,0xf0(%rsp)
mov    0x48(%rsp),%rax
lea    0x0(,%rax,4),%r15
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xe8(%rsp)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xd0(%rsp)
mov    %r15,%rdi
call   10a0 <malloc@plt>
mov    %rax,0xc8(%rsp)
mov    0x8(%rsp),%rax
cmp    $0x2,%eax
mov    0x10(%rsp),%rbp
jl     1733 <mir_xnyn+0x5b3>
mov    0x48(%rsp),%rcx
lea    0x0(,%rcx,8),%r15
mov    %eax,%eax
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %ebx,%ebx
mov    0x30(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rbx,1),%rdi
mov    0x0(%rbp,%rbx,1),%rsi
mov    %r15,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r14,%rbx,1),%rdi
mov    0x10(%rsp),%rax
mov    0x8(%rax,%rbx,1),%rsi
mov    %r15,%rdx
call   1080 <memcpy@plt>
mov    0x10(%rsp),%rbp
add    $0x10,%rbx
cmp    %rbx,(%rsp)
jne    16d0 <mir_xnyn+0x550>
testb  $0x1,0x50(%rsp)
mov    0x8(%rsp),%rax
je     1733 <mir_xnyn+0x5b3>
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,1),%rdi
mov    0x0(%rbp,%rbx,1),%rsi
mov    %r15,%rdx
call   1080 <memcpy@plt>
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%rax
cmpl   $0x2,0x18(%rsp)
jl     17d2 <mir_xnyn+0x652>
mov    0x48(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
cltq
mov    0x18(%rsp),%edx
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
mov    %rcx,%rbp
mov    %rdx,0x50(%rsp)
lea    0x0(,%rdx,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,(%rsp)
xor    %r14d,%r14d
mov    0x20(%rsp),%r15
nopl   0x0(%rax)
mov    (%r15,%r14,1),%rdi
mov    (%rbx,%r14,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x8(%r15,%r14,1),%rdi
mov    0x8(%rbx,%r14,1),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
add    $0x10,%r14
cmp    %r14,(%rsp)
jne    1780 <mir_xnyn+0x600>
mov    %rbp,%rdx
testb  $0x1,0x50(%rsp)
mov    0x10(%rsp),%rbp
je     17d2 <mir_xnyn+0x652>
mov    0x20(%rsp),%rax
mov    (%rax,%r14,1),%rdi
mov    (%r14,%rbx,1),%rsi
call   1080 <memcpy@plt>
mov    0x10(%rsp),%rbp
mov    %rbp,%rdi
mov    0x2c(%rsp),%esi
mov    0x38(%rsp),%r14
mov    %r14d,%edx
xor    %ecx,%ecx
mov    0x8(%rsp),%r8
mov    0x58(%rsp),%rbx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xe8(%rsp)
push   0xf8(%rsp)
push   0x50(%rsp)
mov    0x88(%rsp),%r15
push   %r15
call   1040 <make_box2ind@plt>
mov    0x28(%rsp),%rsi
add    $0x20,%rsp
cmp    $0x1,%esi
jne    185f <mir_xnyn+0x6df>
mov    0x100(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x0(%rbp),%rdi
mov    %r14d,%esi
movsd  %xmm0,0x140(%rsp)
mov    0x28(%rsp),%edx
mov    0xb0(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xa8(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    1892 <mir_xnyn+0x712>
lea    -0x1(%rsi),%r8d
mov    0x30(%rsp),%rdi
mov    %r14d,%edx
xor    %ecx,%ecx
mov    %ebx,%r9d
xor    %eax,%eax
push   0xb8(%rsp)
push   0xc8(%rsp)
push   0xe0(%rsp)
push   %r15
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
mov    0x88(%rsp),%rbp
mov    0x18(%rsp),%rsi
cmp    $0x1,%esi
jne    18ed <mir_xnyn+0x76d>
movslq 0x8(%rsp),%rax
mov    0x100(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mov    %r14d,%esi
movsd  %xmm0,0x138(%rsp)
mov    0x28(%rsp),%edx
mov    0xa0(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    0x90(%rsp),%r9
mov    $0x1,%al
call   1050 <make_box1@plt>
jmp    191d <mir_xnyn+0x79d>
lea    -0x1(%rsi),%r8d
mov    0x20(%rsp),%rdi
mov    %r14d,%edx
xor    %ecx,%ecx
mov    %ebx,%r9d
xor    %eax,%eax
push   0x98(%rsp)
push   0x70(%rsp)
push   0xd8(%rsp)
push   %r15
call   1040 <make_box2ind@plt>
add    $0x20,%rsp
test   %r14d,%r14d
mov    0x80(%rsp),%r10
movsd  0xe0(%rsp),%xmm1
jle    1e46 <mir_xnyn+0xcc6>
mov    0x8(%rsp),%rcx
movslq %ecx,%rax
mov    %rax,0x50(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0xfc(%rsp)
mov    0x18(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xf8(%rsp)
mov    %r14d,%eax
mov    %rax,0x158(%rsp)
mov    0x2c(%rsp),%eax
mov    %eax,%edx
mov    %ecx,%ecx
mov    %rcx,0x150(%rsp)
mov    0xd8(%rsp),%ecx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x148(%rsp)
lea    -0x1(%rcx),%r14
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0xd8(%rsp)
mov    %eax,%ebp
and    $0x3,%ebp
and    $0xfffffffc,%eax
mov    %rax,0x130(%rsp)
mov    %r14,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
pxor   %xmm2,%xmm2
xor    %edx,%edx
mov    0x10(%rsp),%rdi
mov    0x58(%rsp),%r9
mov    %rbp,0x118(%rsp)
jmp    1a80 <mir_xnyn+0x900>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rbp
mov    0x50(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rdi
mov    0x40(%rsp),%rax
mov    (%rsp),%r15
mov    (%rax,%r15,4),%esi
movsd  0x138(%rsp),%xmm0
mov    0x28(%rsp),%edx
mov    0xa0(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    0x90(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
mov    0x88(%rsp),%rsi
mov    %r15,%rdx
mov    %rbp,%rdi
mov    0x58(%rsp),%r9
mov    0x80(%rsp),%r10
movsd  0xe0(%rsp),%xmm1
movsd  0x38(%rsp),%xmm2
mov    0x118(%rsp),%rbp
mov    0x70(%rsp),%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm0
cltq
addsd  (%rsi,%rax,8),%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rdx
cmp    0x158(%rsp),%rdx
je     1e4d <mir_xnyn+0xccd>
mov    0x40(%rsp),%rax
mov    %rdx,%rcx
mov    %rdx,(%rsp)
movslq (%rax,%rdx,4),%r8
cmpl   $0x0,0x2c(%rsp)
jle    1b48 <mir_xnyn+0x9c8>
cmpq   $0x3,0x148(%rsp)
jae    1ab0 <mir_xnyn+0x930>
xor    %eax,%eax
jmp    1b10 <mir_xnyn+0x990>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x130(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
mov    0x8(%rdi,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
mov    0x10(%rdi,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
mov    0x18(%rdi,%rax,8),%rcx
movsd  (%rcx,%r8,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1ac0 <mir_xnyn+0x940>
test   %rbp,%rbp
je     1b48 <mir_xnyn+0x9c8>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
lea    (%rdi,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rdx,8),%rsi
movsd  (%rsi,%r8,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1b30 <mir_xnyn+0x9b0>
movq   %xmm2,0x38(%rsp)
mov    0x2c(%rsp),%esi
xor    %edx,%edx
mov    0x8(%rsp),%r15
mov    %r15d,%ecx
movsd  0x78(%rsp),%xmm0
mov    $0x1,%al
push   %r12
push   0xf0(%rsp)
push   0x100(%rsp)
push   %r10
call   1060 <neiK@plt>
movapd 0x14cd(%rip),%xmm4
movapd 0x14c5(%rip),%xmm3
mov    0xa0(%rsp),%rdi
add    $0x20,%rsp
xorpd  %xmm5,%xmm5
xorpd  %xmm1,%xmm1
test   %r15d,%r15d
mov    0x160(%rsp),%r8
mov    0x150(%rsp),%rbp
mov    0xd8(%rsp),%r9
jle    1c60 <mir_xnyn+0xae0>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    1bdd <mir_xnyn+0xa5d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbp,%rax
je     1c60 <mir_xnyn+0xae0>
test   %edi,%edi
jle    1bd0 <mir_xnyn+0xa50>
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    $0x1,%edx
test   %r9,%r9
je     1c3d <mir_xnyn+0xabd>
nopl   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    1c00 <mir_xnyn+0xa80>
test   $0x1,%r14b
je     1bd0 <mir_xnyn+0xa50>
movslq (%r12,%rdx,4),%rdx
subsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm3,%xmm0
maxsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
jmp    1bd0 <mir_xnyn+0xa50>
nopl   (%rax)
cmpl   $0x0,0x18(%rsp)
mov    0x10(%rsp),%rbp
jle    1d10 <mir_xnyn+0xb90>
xorpd  %xmm5,%xmm5
mov    0x50(%rsp),%rax
jmp    1c8d <mir_xnyn+0xb0d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r8,%rax
jge    1d10 <mir_xnyn+0xb90>
test   %edi,%edi
jle    1c80 <mir_xnyn+0xb00>
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x0(%rbp,%rax,8),%rcx
mov    $0x1,%edx
test   %r9,%r9
je     1ced <mir_xnyn+0xb6d>
nopw   0x0(%rax,%rax,1)
movslq (%r12,%rdx,4),%rsi
movapd %xmm0,%xmm2
subsd  (%rcx,%rsi,8),%xmm2
andpd  %xmm4,%xmm2
maxsd  %xmm5,%xmm2
movslq 0x4(%r12,%rdx,4),%rsi
movapd %xmm0,%xmm5
subsd  (%rcx,%rsi,8),%xmm5
andpd  %xmm4,%xmm5
maxsd  %xmm2,%xmm5
lea    (%rbx,%rdx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdx
cmp    $0x1,%rsi
jne    1cb0 <mir_xnyn+0xb30>
test   $0x1,%r14b
je     1c80 <mir_xnyn+0xb00>
movslq (%r12,%rdx,4),%rdx
subsd  (%rcx,%rdx,8),%xmm0
andpd  %xmm3,%xmm0
maxsd  %xmm5,%xmm0
movapd %xmm0,%xmm5
jmp    1c80 <mir_xnyn+0xb00>
nopl   (%rax)
cmp    $0x2,%r15d
movapd %xmm5,0x100(%rsp)
jl     1d90 <mir_xnyn+0xc10>
mov    0xd0(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x30(%rsp),%rdi
xor    %edx,%edx
mov    0xfc(%rsp),%ecx
mov    %r15d,%r8d
mov    0x58(%rsp),%rbp
mov    %ebp,%r9d
movsd  0x78(%rsp),%xmm0
mov    $0x2,%al
push   0xb8(%rsp)
push   0xc8(%rsp)
call   1070 <neiE@plt>
movaps 0x110(%rsp),%xmm1
add    $0x10,%rsp
mov    %eax,0x70(%rsp)
mov    0x18(%rsp),%r8
cmp    $0x2,%r8d
jl     19e0 <mir_xnyn+0x860>
jmp    1de9 <mir_xnyn+0xc69>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%rbp),%rdi
mov    0x40(%rsp),%rax
mov    (%rsp),%rcx
mov    (%rax,%rcx,4),%esi
movsd  0x140(%rsp),%xmm0
mov    0x28(%rsp),%edx
mov    0xb0(%rsp),%rcx
mov    0x30(%rsp),%r8
mov    0xa8(%rsp),%r9
mov    $0x2,%al
call   1090 <neiE1@plt>
movaps 0x100(%rsp),%xmm1
mov    %eax,0x70(%rsp)
mov    0x18(%rsp),%r8
mov    0x58(%rsp),%rbp
cmp    $0x2,%r8d
jl     19e0 <mir_xnyn+0x860>
mov    0xc8(%rsp),%rax
mov    (%rsp),%r15
mov    (%rax,%r15,4),%esi
mov    0x20(%rsp),%rdi
xor    %edx,%edx
mov    0xf8(%rsp),%ecx
mov    %ebp,%r9d
movsd  0x78(%rsp),%xmm0
mov    $0x2,%al
push   0x98(%rsp)
push   0x70(%rsp)
call   1070 <neiE@plt>
mov    0x98(%rsp),%rsi
mov    %rbp,%r9
mov    %r15,%rdx
add    $0x10,%rsp
mov    0x80(%rsp),%r10
mov    0x10(%rsp),%rdi
jmp    1a40 <mir_xnyn+0x8c0>
mov    %rbp,%rsi
pxor   %xmm2,%xmm2
divsd  %xmm1,%xmm2
mov    0x48(%rsp),%rax
movsd  (%rsi,%rax,8),%xmm0
movslq %r10d,%rax
mov    0x128(%rsp),%r14
addsd  (%r14,%rax,8),%xmm0
subsd  %xmm2,%xmm0
mov    0x120(%rsp),%rax
movsd  %xmm0,(%rax)
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xe8(%rsp),%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    0x60(%rsp),%rbp
mov    0xf0(%rsp),%r15
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1eb0 <mir_xnyn+0xd30>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0xd0(%rsp),%rdi
call   1030 <free@plt>
mov    0xc8(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x1,0x8(%rsp)
mov    0x30(%rsp),%r15
mov    0xc0(%rsp),%r12
jne    1f1e <mir_xnyn+0xd9e>
mov    0xa8(%rsp),%rdi
call   1030 <free@plt>
mov    0xb0(%rsp),%rdi
call   1030 <free@plt>
jmp    1f82 <mir_xnyn+0xe02>
xor    %ebx,%ebx
mov    0x60(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1f30 <mir_xnyn+0xdb0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0xb8(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
jle    1f82 <mir_xnyn+0xe02>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1f70 <mir_xnyn+0xdf0>
mov    0x68(%rsp),%r12
mov    %r15,%rdi
call   1030 <free@plt>
cmpl   $0x1,0x18(%rsp)
mov    0x60(%rsp),%rbp
jne    1fbc <mir_xnyn+0xe3c>
mov    0x90(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%r15
jmp    2022 <mir_xnyn+0xea2>
xor    %ebx,%ebx
mov    0x20(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1fd0 <mir_xnyn+0xe50>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rax
test   %eax,%eax
jle    2022 <mir_xnyn+0xea2>
mov    %eax,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2010 <mir_xnyn+0xe90>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
movdqa 0xfb5(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%dl
jne    12a5 <mir_xnyn+0x125>
jmp    12cc <mir_xnyn+0x14c>

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

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