#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
scalar_t__ pow(double, double);
double sqrt(double);
int nel_min(double (*funcpt)(double *, int), double *xc, int N, double *dx,
            double fsval, int MAXITER, int *niter, double eps, double *xf) {
  int rcode, NN, i, j, ct, ctl;
  int ihi, ilo, L, siter;
  double reqmin, rcoeff, ecoeff, ccoeff, fn, del;
  double ylo, ynl, temp, ys, yss;
  double *P, *Y, *PB, *PS, *PSS, *PM, *PL, *xi, *xmin;
  double ysum, yavg, s, dval;
  rcode = 0;
  reqmin = eps;
  rcoeff = 1.0;
  ecoeff = 2.0;
  ccoeff = 0.5;
  del = 1.0;
  NN = N + 1;
  ct = N * N;
  *niter = 0;
  siter = MAXITER;
  s = 1.0;
  ctl = 0;
  dval = 1.0e-03;
  P = (double *)malloc(sizeof(double) * N * NN);
  Y = (double *)malloc(sizeof(double) * NN);
  PB = (double *)malloc(sizeof(double) * N);
  PS = (double *)malloc(sizeof(double) * N);
  PSS = (double *)malloc(sizeof(double) * N);
  PM = (double *)malloc(sizeof(double) * N);
  PL = (double *)malloc(sizeof(double) * N);
  xi = (double *)malloc(sizeof(double) * N);
  xmin = (double *)malloc(sizeof(double) * N);
  for (i = 0; i < N; ++i) {
    xi[i] = xc[i];
  }
  while (ctl == 0 && *niter < siter) {
    for (i = 0; i < N; ++i) {
      P[ct + i] = xi[i];
    }
    fn = funcpt(xi, N);
    Y[N] = fn;
    for (i = 0; i < N; ++i) {
      xi[i] += dx[i] * del;
      ct = i * N;
      for (j = 0; j < N; ++j) {
        P[ct + j] = xi[j];
      }
      fn = funcpt(xi, N);
      Y[i] = fn;
      xi[i] -= dx[i] * del;
    }
    ylo = Y[0];
    ilo = 0;
    for (i = 1; i < NN; ++i) {
      if (Y[i] < ylo) {
        ylo = Y[i];
        ilo = i;
      }
    }
    ct = ilo * N;
    for (i = 0; i < N; ++i) {
      PL[i] = P[ct + i];
    }
    while (fabs(s) > reqmin && *niter < siter) {
      *niter = *niter + 1;
      ynl = Y[0];
      ihi = 0;
      for (i = 1; i < NN; ++i) {
        if (Y[i] > ynl) {
          ynl = Y[i];
          ihi = i;
        }
      }
      ct = N;
      for (i = 0; i < N; i++) {
        temp = 0.0;
        for (j = 0; j < NN; ++j) {
          temp += P[j * ct + i];
        }
        temp -= P[ihi * ct + i];
        PB[i] = temp / (double)N;
      }
      ct = ihi * N;
      for (i = 0; i < N; ++i) {
        PS[i] = (1.0 + rcoeff) * PB[i] - rcoeff * P[ct + i];
      }
      ys = funcpt(PS, N);
      if (ys < ylo) {
        for (i = 0; i < N; ++i) {
          PSS[i] = ecoeff * PS[i] + (1.0 - ecoeff) * PB[i];
        }
        yss = funcpt(PSS, N);
        if (yss < ys) {
          for (i = 0; i < N; ++i) {
            P[ct + i] = PSS[i];
          }
          Y[ihi] = yss;
        } else {
          for (i = 0; i < N; ++i) {
            P[ct + i] = PS[i];
          }
          Y[ihi] = ys;
        }
      } else {
        L = 0;
        for (i = 0; i < NN; ++i) {
          if (Y[i] > ys) {
            L++;
          }
        }
        if (L == 0) {
          for (i = 0; i < N; ++i) {
            PSS[i] = ccoeff * P[ct + i] + (1.0 - ccoeff) * PB[i];
          }
          yss = funcpt(PSS, N);
          if (yss <= Y[ihi]) {
            for (i = 0; i < N; ++i) {
              P[ct + i] = PSS[i];
            }
            Y[ihi] = yss;
          } else {
            for (i = 0; i < NN; ++i) {
              ct = i * N;
              for (j = 0; j < N; ++j) {
                P[ct + j] = 0.5 * (P[ct + j] + PL[j]);
                PM[j] = P[ct + j];
              }
              Y[i] = funcpt(PM, N);
            }
            ylo = Y[0];
            ilo = 0;
            for (i = 1; i < NN; ++i) {
              if (Y[i] < ylo) {
                ylo = Y[i];
                ilo = i;
              }
            }
            ct = ilo * N;
            for (i = 0; i < N; ++i) {
              PL[i] = P[ct + i];
            }
          }
        }
        if (L == 1) {
          for (i = 0; i < N; ++i) {
            PSS[i] = ccoeff * P[ct + i] + (1.0 - ccoeff) * PB[i];
          }
          yss = funcpt(PSS, N);
          if (yss <= ys) {
            ct = ihi * N;
            for (i = 0; i < N; ++i) {
              P[ct + i] = PSS[i];
            }
            Y[ihi] = yss;
          } else {
            ct = ihi * N;
            for (i = 0; i < N; ++i) {
              P[ct + i] = PS[i];
            }
            Y[ihi] = ys;
          }
        }
        if (L > 1) {
          ct = ihi * N;
          for (i = 0; i < N; ++i) {
            P[ct + i] = PS[i];
          }
          Y[ihi] = ys;
        }
      }
      if (Y[ihi] < ylo) {
        ylo = Y[ihi];
        ilo = ihi;
      }
      ysum = 0.0;
      for (j = 0; j <= N; j++) {
        ysum += Y[j];
      }
      yavg = ysum / (N + 1);
      s = 0.0;
      for (j = 0; j <= N; j++) {
        s += pow((Y[j] - yavg), 2.0);
      }
      s = sqrt(s);
      if (fabs(s) < reqmin) {
        ctl = 1;
      }
    }
    ct = ilo * N;
    for (i = 0; i < N; ++i) {
      xmin[i] = P[ct + i];
    }
    ynl = Y[ilo];
    for (i = 0; i < N; ++i) {
      del = dx[i] * dval;
      xmin[i] += del;
      fn = funcpt(xmin, N);
      if (fn < ynl) {
        ctl = 0;
        break;
      } else {
        ctl++;
      }
      xmin[i] = xmin[i] - 2 * del;
      fn = funcpt(xmin, N);
      if (fn < ynl) {
        ctl = 0;
        break;
      } else {
        ctl++;
      }
    }
    if (ctl == 0) {
      for (i = 0; i < N; ++i) {
        xi[i] = xmin[i];
      }
      del = dval;
      s = 1.0;
    }
  }
  ct = N * N;
  for (i = 0; i < N; ++i) {
    xf[i] = P[ct + i];
  }
  if (rcode == 0 && *niter >= siter) {
    rcode = 4;
  } else if (*niter < siter) {
    rcode = 1;
  }
  free(Y);
  free(P);
  free(PB);
  free(PS);
  free(PSS);
  free(PM);
  free(PL);
  free(xi);
  free(xmin);
  return rcode;
}


x86 assembly (clang, -O0):
<nel_min>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1e7f(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x1e82(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1e6d(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x1e55(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  0x1e22(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x58(%rbp)
movsd  0x1e03(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
movslq -0x48(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xc8(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xd8(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xe0(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xe8(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xf8(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x100(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x108(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1311 <nel_min+0x1d1>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12da <nel_min+0x19a>
jmp    1316 <nel_min+0x1d6>
xor    %eax,%eax
cmpl   $0x0,-0x58(%rbp)
mov    %al,-0x129(%rbp)
jne    133a <nel_min+0x1fa>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
cmp    -0x68(%rbp),%eax
setl   %al
mov    %al,-0x129(%rbp)
mov    -0x129(%rbp),%al
test   $0x1,%al
jne    134d <nel_min+0x20d>
jmp    21e8 <nel_min+0x10a8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1393 <nel_min+0x253>
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1354 <nel_min+0x214>
mov    -0x8(%rbp),%rax
mov    -0x100(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14df <nel_min+0x39f>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1458 <nel_min+0x318>
mov    -0x100(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1419 <nel_min+0x2d9>
mov    -0x8(%rbp),%rax
mov    -0x100(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13ca <nel_min+0x28a>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    155f <nel_min+0x41f>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    154c <nel_min+0x40c>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x4c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1551 <nel_min+0x411>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1500 <nel_min+0x3c0>
mov    -0x60(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15af <nel_min+0x46f>
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1570 <nel_min+0x430>
jmp    15b4 <nel_min+0x474>
movsd  -0x120(%rbp),%xmm0
ff
movaps 0x1a5d(%rip),%xmm1
pand   %xmm1,%xmm0
xor    %eax,%eax
ucomisd -0x70(%rbp),%xmm0
mov    %al,-0x12a(%rbp)
jbe    15ec <nel_min+0x4ac>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
cmp    -0x68(%rbp),%eax
setl   %al
mov    %al,-0x12a(%rbp)
mov    -0x12a(%rbp),%al
test   $0x1,%al
jne    15ff <nel_min+0x4bf>
jmp    1ff2 <nel_min+0xeb2>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x5c(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    168a <nel_min+0x54a>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jbe    1677 <nel_min+0x537>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    167c <nel_min+0x53c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    162f <nel_min+0x4ef>
mov    -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1754 <nel_min+0x614>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    16f8 <nel_min+0x5b8>
mov    -0xc8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16b5 <nel_min+0x575>
mov    -0xc8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1697 <nel_min+0x557>
mov    -0x5c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17e5 <nel_min+0x6a5>
movsd  0x188f(%rip),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1765 <nel_min+0x625>
mov    -0x8(%rbp),%rax
mov    -0xe0(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    197a <nel_min+0x83a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1882 <nel_min+0x742>
movsd  -0x80(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x17c1(%rip),%xmm1
subsd  -0x80(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    181e <nel_min+0x6de>
mov    -0x8(%rbp),%rax
mov    -0xe8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1917 <nel_min+0x7d7>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18fa <nel_min+0x7ba>
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    18bb <nel_min+0x77b>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1975 <nel_min+0x835>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    195d <nel_min+0x81d>
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    191e <nel_min+0x7de>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e9f <nel_min+0xd5f>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    19ce <nel_min+0x88e>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    19bb <nel_min+0x87b>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    19c0 <nel_min+0x880>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1988 <nel_min+0x848>
cmpl   $0x0,-0x64(%rbp)
jne    1c9c <nel_min+0xb5c>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a4e <nel_min+0x90e>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x15f8(%rip),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
mov    -0xd8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    19df <nel_min+0x89f>
mov    -0x8(%rbp),%rax
mov    -0xe8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1aeb <nel_min+0x9ab>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ace <nel_min+0x98e>
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1a8f <nel_min+0x94f>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c97 <nel_min+0xb57>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1bc2 <nel_min+0xa82>
mov    -0x4c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b94 <nel_min+0xa54>
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xf8(%rbp),%rax
movslq -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x14c8(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1b0f <nel_min+0x9cf>
mov    -0x8(%rbp),%rax
mov    -0xf0(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1af2 <nel_min+0x9b2>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1c42 <nel_min+0xb02>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c2f <nel_min+0xaef>
mov    -0xd0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x4c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1c34 <nel_min+0xaf4>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1be3 <nel_min+0xaa3>
mov    -0x60(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c92 <nel_min+0xb52>
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1c53 <nel_min+0xb13>
jmp    1c97 <nel_min+0xb57>
jmp    1c9c <nel_min+0xb5c>
cmpl   $0x1,-0x64(%rbp)
jne    1e28 <nel_min+0xce8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d1c <nel_min+0xbdc>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x132a(%rip),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
mov    -0xd8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1cad <nel_min+0xb6d>
mov    -0x8(%rbp),%rax
mov    -0xe8(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1dbb <nel_min+0xc7b>
mov    -0x5c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d9e <nel_min+0xc5e>
mov    -0xe8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1d5f <nel_min+0xc1f>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e23 <nel_min+0xce3>
mov    -0x5c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e0b <nel_min+0xccb>
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1dcc <nel_min+0xc8c>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e28 <nel_min+0xce8>
cmpl   $0x1,-0x64(%rbp)
jle    1e9a <nel_min+0xd5a>
mov    -0x5c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e82 <nel_min+0xd42>
mov    -0xe0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1e43 <nel_min+0xd03>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e9f <nel_min+0xd5f>
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1edf <nel_min+0xd9f>
mov    -0xd0(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1f2b <nel_min+0xdeb>
mov    -0xd0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1ef1 <nel_min+0xdb1>
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1faf <nel_min+0xe6f>
mov    -0xd0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x118(%rbp),%xmm0
ff
movsd  0x1091(%rip),%xmm1
call   1050 <pow@plt>
cvtsi2sd %rax,%xmm0
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1f5b <nel_min+0xe1b>
movsd  -0x120(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movaps 0x104d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1fed <nel_min+0xead>
movl   $0x1,-0x58(%rbp)
jmp    15b4 <nel_min+0x474>
mov    -0x60(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2042 <nel_min+0xf02>
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x108(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2003 <nel_min+0xec3>
mov    -0xd0(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2178 <nel_min+0x1038>
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x108(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    20e5 <nel_min+0xfa5>
movl   $0x0,-0x58(%rbp)
jmp    2178 <nel_min+0x1038>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x108(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x108(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   *%rax
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    215c <nel_min+0x101c>
movl   $0x0,-0x58(%rbp)
jmp    2178 <nel_min+0x1038>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    216a <nel_min+0x102a>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2061 <nel_min+0xf21>
cmpl   $0x0,-0x58(%rbp)
jne    21e3 <nel_min+0x10a3>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    21c3 <nel_min+0x1083>
mov    -0x108(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2189 <nel_min+0x1049>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xe2d(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
jmp    1316 <nel_min+0x1d6>
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2235 <nel_min+0x10f5>
mov    -0xc8(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    21f9 <nel_min+0x10b9>
cmpl   $0x0,-0x44(%rbp)
jne    225a <nel_min+0x111a>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
cmp    -0x68(%rbp),%eax
jl     225a <nel_min+0x111a>
movl   $0x4,-0x44(%rbp)
jmp    2275 <nel_min+0x1135>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
cmp    -0x68(%rbp),%eax
jge    2270 <nel_min+0x1130>
movl   $0x1,-0x44(%rbp)
jmp    2275 <nel_min+0x1135>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x100(%rbp),%rdi
call   1030 <free@plt>
mov    -0x108(%rbp),%rdi
call   1030 <free@plt>
mov    -0x44(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nel_min>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
movsd  %xmm1,0x1e0(%rsp)
mov    %r8d,0xe8(%rsp)
mov    %rcx,0x1b0(%rsp)
mov    %edx,%r15d
mov    %rsi,%rbp
mov    %rdi,0x88(%rsp)
lea    0x1(%r15),%edi
mov    %r9,0xd0(%rsp)
movl   $0x0,(%r9)
movslq %edx,%r14
lea    0x0(,%r14,8),%ebx
mov    %edi,0x114(%rsp)
imul   %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    0x8(,%r14,8),%edi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0xe0(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x1a8(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0xf0(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r12
mov    %rax,%r13
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0xd8(%rsp)
mov    %r15,%r11
mov    %r15d,%r10d
mov    %r14,0x108(%rsp)
test   %r14d,%r14d
jle    13d6 <nel_min+0x296>
cmp    $0x4,%r11d
jb     125b <nel_min+0x11b>
lea    0x0(,%r10,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%r12
jae    12e2 <nel_min+0x1a2>
lea    (%r12,%r10,8),%rcx
cmp    %rbp,%rcx
jbe    12e2 <nel_min+0x1a2>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r10,%rsi
mov    %r10,%rdx
and    $0x3,%rdx
je     1287 <nel_min+0x147>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1270 <nel_min+0x130>
cmp    $0x3,%rsi
jb     13d6 <nel_min+0x296>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r13,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r13,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    12a0 <nel_min+0x160>
jmp    13d6 <nel_min+0x296>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0xc,%rsi
jae    1308 <nel_min+0x1c8>
xor    %esi,%esi
jmp    1384 <nel_min+0x244>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rsi,8),%xmm0
movups 0x10(%rbp,%rsi,8),%xmm1
movups %xmm0,0x0(%r13,%rsi,8)
movups %xmm1,0x10(%r13,%rsi,8)
movups 0x20(%rbp,%rsi,8),%xmm0
movups 0x30(%rbp,%rsi,8),%xmm1
movups %xmm0,0x20(%r13,%rsi,8)
movups %xmm1,0x30(%r13,%rsi,8)
movups 0x40(%rbp,%rsi,8),%xmm0
movups 0x50(%rbp,%rsi,8),%xmm1
movups %xmm0,0x40(%r13,%rsi,8)
movups %xmm1,0x50(%r13,%rsi,8)
movups 0x60(%rbp,%rsi,8),%xmm0
movupd 0x70(%rbp,%rsi,8),%xmm1
movups %xmm0,0x60(%r13,%rsi,8)
movupd %xmm1,0x70(%r13,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1320 <nel_min+0x1e0>
test   %r8,%r8
je     13cd <nel_min+0x28d>
lea    (%r12,%rsi,8),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,8),%rsi
add    %rbp,%rsi
shl    $0x5,%r8
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movupd %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    13b0 <nel_min+0x270>
cmp    %r10,%rcx
jne    125d <nel_min+0x11d>
mov    0x108(%rsp),%rax
imul   %eax,%eax
mov    %eax,0x13c(%rsp)
mov    0x114(%rsp),%eax
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x50(%rsp)
lea    -0x4(%rcx),%rbp
mov    %rbp,0x68(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
lea    -0x1(%rax),%rsi
mov    %eax,%ecx
mov    %rax,%rbx
mov    %rax,0x168(%rsp)
and    $0xfffffffc,%ecx
mov    %rcx,0x1a0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x218(%rsp)
mov    %r12,%r14
mov    %rcx,%r12
shr    $0x2,%r12
add    $0x1,%r12
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0x248(%rsp)
lea    -0x2(%rcx),%rdx
mov    %rdx,0x240(%rsp)
shr    %rdx
add    $0x1,%rdx
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x1c8(%rsp)
mov    %rbp,%rcx
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
and    %rdi,%rcx
mov    %rcx,0xa8(%rsp)
mov    %r10d,%ecx
and    $0x3,%ecx
mov    %rcx,0x20(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x118(%rsp)
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x100(%rsp)
mov    %ebx,%ecx
and    $0x3,%ecx
mov    %rcx,0x1e8(%rsp)
mov    0xe0(%rsp),%rsi
lea    (%rsi,%r10,8),%rax
mov    %rdi,%r15
mov    0x38(%rsp),%r9
cmp    %rax,%r9
setb   %cl
lea    (%r9,%r10,8),%r8
cmp    %r8,%rsi
mov    %rsi,%rdi
mov    %r10,%rbx
setb   %r10b
and    %cl,%r10b
mov    %r10b,0x65(%rsp)
mov    %rbx,%rcx
neg    %rcx
mov    %rcx,0x130(%rsp)
lea    0x2(%r15),%r10
mov    %r12,%rcx
mov    %r12,0x210(%rsp)
and    %r10,%r12
mov    %r12,0x200(%rsp)
mov    0x48(%rsp),%r15
cmp    %rax,%r15
setb   %cl
lea    (%r15,%rbx,8),%rsi
cmp    %rsi,%rdi
setb   %al
and    %cl,%al
mov    0xf0(%rsp),%rdi
lea    (%rdi,%rbx,8),%r12
mov    0x1a8(%rsp),%rcx
mov    %r12,0x198(%rsp)
cmp    %r12,%rcx
setb   %r12b
lea    (%rcx,%rbx,8),%rcx
mov    %rcx,0x258(%rsp)
cmp    %rcx,%rdi
setb   %cl
and    %r12b,%cl
mov    %cl,0x67(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x238(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x220(%rsp)
mov    %r8,0x158(%rsp)
cmp    %r8,%r15
setb   %cl
mov    %rsi,0x120(%rsp)
cmp    %rsi,%r9
setb   %dl
and    %cl,%dl
mov    %r11,%rsi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,0x128(%rsp)
mov    %al,0x1f(%rsp)
or     %al,%dl
mov    %dl,0x66(%rsp)
mov    %rbp,%rcx
mov    %rbp,0x80(%rsp)
and    %rbp,%r10
mov    %r10,0x208(%rsp)
mov    %rbx,%rbp
mov    %r15,%rdi
mov    0x168(%rsp),%rcx
mov    %ecx,%eax
and    $0x7,%eax
mov    %rax,0x1d8(%rsp)
mov    %ecx,%eax
mov    %rcx,%rbx
and    $0xfffffff8,%eax
mov    %rax,0x228(%rsp)
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rbp,8),%rax
mov    %rax,0x1f8(%rsp)
cmp    %rax,%r14
setb   %cl
lea    (%r14,%rbp,8),%rax
mov    %rax,0x1f0(%rsp)
cmp    %rax,%rdx
setb   %al
and    %cl,%al
mov    %al,0x64(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x114(%rsp),%xmm0
movsd  %xmm0,0x230(%rsp)
add    $0x10,%r14
mov    %r14,0x180(%rsp)
mov    0x1c8(%rsp),%r8
shl    $0x5,%r8
mov    %r8,0x70(%rsp)
mov    0x108(%rsp),%rcx
mov    %rcx,%rax
shl    $0x4,%rax
mov    %rax,0x270(%rsp)
mov    %rcx,%rax
shl    $0x5,%rax
mov    %rax,0x268(%rsp)
lea    0x0(,%rbp,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x188(%rsp)
movsd  0x3966(%rip),%xmm0
movapd %xmm0,%xmm5
movapd %xmm0,%xmm2
lea    (%r11,%r11,1),%eax
mov    %eax,0x1bc(%rsp)
mov    0x30(%rsp),%r15
lea    (%r15,%rbp,8),%rax
mov    %rax,0x78(%rsp)
lea    -0x2(%rbx),%rax
mov    %rax,0x190(%rsp)
lea    0x70(%r15),%rax
mov    %rax,0xb0(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x58(%rsp)
lea    0x18(%r15),%rax
mov    %rax,0xb8(%rsp)
lea    0x0(,%rcx,8),%r12
mov    0xf0(%rsp),%rax
lea    0x10(%rax),%rax
mov    %rax,0x1c0(%rsp)
lea    (%r12,%r12,2),%rax
mov    %rax,0x260(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x160(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0x170(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x178(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0x1d0(%rsp)
mov    0x13c(%rsp),%eax
mov    %eax,0x10(%rsp)
mov    0xd0(%rsp),%r14
mov    %r15,%r10
mov    0x28(%rsp),%r8
mov    %rbp,0x8(%rsp)
mov    %r11,0xc8(%rsp)
mov    %r13,0x250(%rsp)
jmp    1788 <nel_min+0x648>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %ebx,%ebx
jne    4505 <nel_min+0x33c5>
mov    0xe8(%rsp),%eax
cmp    %eax,(%r14)
jge    4505 <nel_min+0x33c5>
mov    %r11,%rsi
test   %esi,%esi
movsd  %xmm2,0xf8(%rsp)
movapd %xmm5,0x90(%rsp)
jle    1890 <nel_min+0x750>
movslq 0x10(%rsp),%rax
cmp    $0x4,%esi
jb     17e3 <nel_min+0x6a3>
lea    (%r10,%rax,8),%rcx
cmp    0x1f0(%rsp),%rcx
jae    18ba <nel_min+0x77a>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%r13
jae    18ba <nel_min+0x77a>
xor    %ecx,%ecx
mov    0x88(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
test   %rdi,%rdi
je     1826 <nel_min+0x6e6>
lea    (%r10,%rax,8),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1810 <nel_min+0x6d0>
cmp    $0x3,%rdx
jb     19d0 <nel_min+0x890>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopl   0x0(%rax)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1840 <nel_min+0x700>
jmp    19d0 <nel_min+0x890>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
call   *0x88(%rsp)
mov    0xc8(%rsp),%r11
mov    0x28(%rsp),%r8
mov    0x108(%rsp),%rax
movsd  %xmm0,(%r8,%rax,8)
jmp    1c80 <nel_min+0xb40>
cmpq   $0xc,0x68(%rsp)
jae    18db <nel_min+0x79b>
xor    %ecx,%ecx
mov    0x88(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x70(%rsp),%rbx
jmp    1975 <nel_min+0x835>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
mov    0x88(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x70(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,8)
movups %xmm1,-0x60(%rdx,%rcx,8)
movups 0x20(%r13,%rcx,8),%xmm0
movups 0x30(%r13,%rcx,8),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,8)
movups %xmm1,-0x40(%rdx,%rcx,8)
movups 0x40(%r13,%rcx,8),%xmm0
movups 0x50(%r13,%rcx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movupd 0x60(%r13,%rcx,8),%xmm0
movupd 0x70(%r13,%rcx,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm1,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1910 <nel_min+0x7d0>
cmpq   $0x0,0x1c8(%rsp)
je     19bf <nel_min+0x87f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x180(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    19a0 <nel_min+0x860>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbp,%rdx
jne    17f2 <nel_min+0x6b2>
mov    %r13,%rdi
mov    %r11d,%esi
call   *%r8
mov    0xc8(%rsp),%r11
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%r8
mov    0x108(%rsp),%rax
movsd  %xmm0,(%r8,%rax,8)
test   %r11d,%r11d
mov    0x1b0(%rsp),%rax
movsd  0xf8(%rsp),%xmm2
jle    1c80 <nel_min+0xb40>
mov    0x30(%rsp),%r14
mov    0x58(%rsp),%rbp
mov    0xb0(%rsp),%rbx
xor    %r15d,%r15d
jmp    1a98 <nel_min+0x958>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r11d,%esi
call   *0x88(%rsp)
mov    0xc8(%rsp),%r11
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%r8
movsd  %xmm0,(%r8,%r15,8)
movsd  0x0(%r13,%r15,8),%xmm0
mov    0x1b0(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
movsd  0xf8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
add    $0x1,%r15
add    %r12,%rbx
add    %r12,%rbp
add    %r12,%r14
cmp    %rdi,%r15
je     1c80 <nel_min+0xb40>
movsd  (%rax,%r15,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x0(%r13,%r15,8),%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
cmp    $0x4,%r11d
jb     1aee <nel_min+0x9ae>
mov    %r15,%rax
imul   0x108(%rsp),%rax
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,8),%rcx
cmp    0x1f0(%rsp),%rcx
mov    0x70(%rsp),%rsi
jae    1b90 <nel_min+0xa50>
add    %rdi,%rax
lea    (%rdx,%rax,8),%rax
cmp    %rax,%r13
jae    1b90 <nel_min+0xa50>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   $0x3,%dil
je     1b27 <nel_min+0x9e7>
mov    0x20(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1b10 <nel_min+0x9d0>
cmp    $0x3,%rcx
jb     1a30 <nel_min+0x8f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rbp,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x18(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1b40 <nel_min+0xa00>
jmp    1a30 <nel_min+0x8f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpq   $0xc,0x68(%rsp)
jae    1b9c <nel_min+0xa5c>
xor    %eax,%eax
jmp    1c15 <nel_min+0xad5>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%r13,%rax,8),%xmm0
movups 0x10(%r13,%rax,8),%xmm1
movups %xmm0,-0x70(%rbx,%rax,8)
movups %xmm1,-0x60(%rbx,%rax,8)
movups 0x20(%r13,%rax,8),%xmm0
movups 0x30(%r13,%rax,8),%xmm1
movups %xmm0,-0x50(%rbx,%rax,8)
movups %xmm1,-0x40(%rbx,%rax,8)
movups 0x40(%r13,%rax,8),%xmm0
movups 0x50(%r13,%rax,8),%xmm1
movups %xmm0,-0x30(%rbx,%rax,8)
movups %xmm1,-0x20(%rbx,%rax,8)
movupd 0x60(%r13,%rax,8),%xmm0
movupd 0x70(%r13,%rax,8),%xmm1
movupd %xmm0,-0x10(%rbx,%rax,8)
movupd %xmm1,(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1bb0 <nel_min+0xa70>
testb  $0x3,0x80(%rsp)
03
je     1c5f <nel_min+0xb1f>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
mov    0x180(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1c40 <nel_min+0xb00>
mov    0x50(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1a30 <nel_min+0x8f0>
jmp    1af0 <nel_min+0x9b0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8),%xmm4
test   %r11d,%r11d
jle    1cf0 <nel_min+0xbb0>
cmpq   $0x3,0x190(%rsp)
jae    1d40 <nel_min+0xc00>
xor    %edx,%edx
mov    $0x1,%eax
mov    0xd0(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r10
mov    0xf0(%rsp),%rbx
mov    0xd8(%rsp),%r9
mov    0x100(%rsp),%rbp
movsd  0x128(%rsp),%xmm3
movapd 0x90(%rsp),%xmm5
jmp    1df0 <nel_min+0xcb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
mov    0xd0(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r10
mov    0xf0(%rsp),%rbx
mov    0xd8(%rsp),%r9
mov    0x100(%rsp),%rbp
movsd  0x128(%rsp),%xmm3
movapd 0x90(%rsp),%xmm5
jmp    1e2f <nel_min+0xcef>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edx,%edx
mov    $0x1,%eax
xor    %ecx,%ecx
mov    0xd0(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r10
mov    0xf0(%rsp),%rbx
mov    0xd8(%rsp),%r9
mov    0x100(%rsp),%rbp
movsd  0x128(%rsp),%xmm3
movapd 0x90(%rsp),%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rax,8),%xmm0
ucomisd %xmm0,%xmm4
cmova  %eax,%edx
movsd  0x8(%r8,%rax,8),%xmm1
minsd  %xmm4,%xmm0
ucomisd %xmm1,%xmm0
mov    %rdx,%rdi
lea    0x1(%rax),%edx
cmovbe %edi,%edx
minsd  %xmm0,%xmm1
movsd  0x10(%r8,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
lea    0x2(%rax),%esi
cmovbe %edx,%esi
minsd  %xmm1,%xmm0
movsd  0x18(%r8,%rax,8),%xmm4
ucomisd %xmm4,%xmm0
lea    0x3(%rax),%edx
cmovbe %esi,%edx
minsd  %xmm0,%xmm4
add    $0x4,%rax
add    $0x4,%rcx
cmp    %rbp,%rcx
jne    1d90 <nel_min+0xc50>
testb  $0x3,0x118(%rsp)
03
je     1e2f <nel_min+0xcef>
mov    0x20(%rsp),%rcx
movapd %xmm4,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r8,%rax,8),%xmm4
ucomisd %xmm4,%xmm0
cmova  %eax,%edx
minsd  %xmm0,%xmm4
add    $0x1,%rax
movapd %xmm4,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1e10 <nel_min+0xcd0>
mov    %edx,%eax
imul   %r11d,%eax
mov    %eax,0x10(%rsp)
test   %r11d,%r11d
jle    2020 <nel_min+0xee0>
movslq 0x10(%rsp),%rdi
cmp    $0x4,%r11d
jb     1e71 <nel_min+0xd31>
mov    0x78(%rsp),%rax
lea    (%rax,%rdi,8),%rcx
cmp    %rcx,%rbx
jae    1f1c <nel_min+0xddc>
lea    (%r15,%rdi,8),%rcx
cmp    0x198(%rsp),%rcx
jae    1f1c <nel_min+0xddc>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
mov    %rdx,%rax
mov    %rcx,%rdx
not    %rdx
add    %rsi,%rdx
test   $0x3,%sil
je     1eb4 <nel_min+0xd74>
lea    (%r15,%rdi,8),%rsi
mov    0x20(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbp
jne    1ea0 <nel_min+0xd60>
cmp    $0x3,%rdx
mov    0x100(%rsp),%rbp
mov    %rax,%rdx
mov    0x8(%rsp),%rsi
jb     2020 <nel_min+0xee0>
mov    0xb8(%rsp),%rax
lea    (%rax,%rdi,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  -0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1ee0 <nel_min+0xda0>
jmp    2020 <nel_min+0xee0>
cmpq   $0xc,0x68(%rsp)
jae    1f2e <nel_min+0xdee>
mov    %rdx,%r11
xor    %ecx,%ecx
jmp    1fac <nel_min+0xe6c>
mov    %rdx,%r11
mov    0xb0(%rsp),%rax
lea    (%rax,%rdi,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rcx,8),%xmm0
movups -0x60(%rdx,%rcx,8),%xmm1
movups %xmm0,(%rbx,%rcx,8)
movups %xmm1,0x10(%rbx,%rcx,8)
movups -0x50(%rdx,%rcx,8),%xmm0
movups -0x40(%rdx,%rcx,8),%xmm1
movups %xmm0,0x20(%rbx,%rcx,8)
movups %xmm1,0x30(%rbx,%rcx,8)
movups -0x30(%rdx,%rcx,8),%xmm0
movups -0x20(%rdx,%rcx,8),%xmm1
movups %xmm0,0x40(%rbx,%rcx,8)
movups %xmm1,0x50(%rbx,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
movupd %xmm0,0x60(%rbx,%rcx,8)
movupd %xmm1,0x70(%rbx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1f50 <nel_min+0xe10>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rax
je     1fff <nel_min+0xebf>
mov    0x1c0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
add    %rdi,%rcx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1fe0 <nel_min+0xea0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
mov    0x8(%rsp),%rsi
cmp    %rsi,%rdx
mov    %r11,%rdx
mov    0xc8(%rsp),%r11
jne    1e78 <nel_min+0xd38>
movapd %xmm5,%xmm0
andpd  0x3004(%rip),%xmm0
xor    %ebx,%ebx
ucomisd 0x1e0(%rsp),%xmm0
jbe    3f90 <nel_min+0x2e50>
mov    (%r14),%eax
xor    %ebx,%ebx
cmp    0xe8(%rsp),%eax
jge    3fa0 <nel_min+0x2e60>
xor    %ebx,%ebx
mov    %r10,%rdi
mov    %r15,%r10
nopw   0x0(%rax,%rax,1)
mov    %rdx,0xc0(%rsp)
mov    %ebx,0xec(%rsp)
add    $0x1,%eax
mov    %eax,(%r14)
mov    $0x0,%r14d
test   %r11d,%r11d
mov    0xe0(%rsp),%r15
mov    0x8(%rsp),%r9
jle    2150 <nel_min+0x1010>
movsd  (%r8),%xmm0
cmpq   $0x3,0x190(%rsp)
jae    20b0 <nel_min+0xf70>
xor    %r14d,%r14d
mov    $0x1,%eax
jmp    2121 <nel_min+0xfe1>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
mov    $0x1,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %eax,%r14d
movsd  0x8(%r8,%rax,8),%xmm2
maxsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm2
lea    0x1(%rax),%edx
cmovbe %r14d,%edx
maxsd  %xmm1,%xmm2
movsd  0x10(%r8,%rax,8),%xmm1
ucomisd %xmm2,%xmm1
lea    0x2(%rax),%esi
cmovbe %edx,%esi
maxsd  %xmm2,%xmm1
movsd  0x18(%r8,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
lea    0x3(%rax),%r14d
cmovbe %esi,%r14d
maxsd  %xmm1,%xmm0
add    $0x4,%rax
add    $0x4,%rcx
cmp    %rbp,%rcx
jne    20c0 <nel_min+0xf80>
testb  $0x3,0x118(%rsp)
03
je     2150 <nel_min+0x1010>
mov    0x20(%rsp),%rcx
movsd  (%r8,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %eax,%r14d
maxsd  %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
add    $0xffffffffffffffff,%rcx
jne    2130 <nel_min+0xff0>
movsd  %xmm4,0x90(%rsp)
mov    %r14d,%eax
imul   %r11d,%eax
mov    %eax,0x40(%rsp)
test   %r11d,%r11d
mov    0x1a0(%rsp),%rbx
mov    0x1e8(%rsp),%r8
jle    23e0 <nel_min+0x12a0>
mov    %r14,0x10(%rsp)
movslq 0x40(%rsp),%rsi
mov    %r10,%rbp
xor    %edx,%edx
mov    %r10,%rdi
mov    %r11,%r14
jmp    21d0 <nel_min+0x1090>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r10,%r13
xorpd  %xmm0,%xmm0
lea    (%rdx,%rsi,1),%rax
mov    %r13,%r10
subsd  0x0(%r13,%rax,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x1,%rdx
add    $0x8,%rbp
cmp    %r9,%rdx
je     22a0 <nel_min+0x1160>
test   %r11d,%r11d
js     21a0 <nel_min+0x1060>
cmpq   $0x3,0x118(%rsp)
jae    21f0 <nel_min+0x10b0>
xorpd  %xmm0,%xmm0
xor    %r10d,%r10d
jmp    2242 <nel_min+0x1102>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    %rbp,%rcx
xor    %r10d,%r10d
mov    0x270(%rsp),%r11
mov    0x268(%rsp),%r15
mov    0x260(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  (%rcx),%xmm0
addsd  (%rcx,%r12,1),%xmm0
addsd  (%rcx,%r11,1),%xmm0
addsd  (%rcx,%r9,1),%xmm0
add    $0x4,%r10
add    %r15,%rcx
cmp    %r10,%rbx
jne    2220 <nel_min+0x10e0>
test   %r8,%r8
mov    %rdi,%r13
mov    0xe0(%rsp),%r15
mov    %r14,%r11
mov    0x8(%rsp),%r9
je     21a7 <nel_min+0x1067>
imul   0x108(%rsp),%r10
add    %rdx,%r10
lea    0x0(,%r10,8),%rax
add    %r13,%rax
mov    %r8,%rcx
nopl   0x0(%rax,%rax,1)
addsd  (%rax),%xmm0
add    %r12,%rax
add    $0xffffffffffffffff,%rcx
jne    2280 <nel_min+0x1140>
jmp    21a7 <nel_min+0x1067>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r11d,%r11d
mov    0x250(%rsp),%r13
mov    0x38(%rsp),%rdi
mov    0x10(%rsp),%r14
jle    23e0 <nel_min+0x12a0>
cmp    $0x4,%r11d
jb     22eb <nel_min+0x11ab>
lea    (%r10,%rsi,8),%rcx
mov    0x78(%rsp),%rax
lea    (%rax,%rsi,8),%rdx
cmp    %rdx,%rdi
setb   %dl
cmp    0x158(%rsp),%rcx
setb   %cl
and    %dl,%cl
or     0x65(%rsp),%cl
je     2376 <nel_min+0x1236>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r9b
je     2316 <nel_min+0x11d6>
movsd  (%r15,%rdx,8),%xmm0
lea    (%rdx,%rsi,1),%rcx
addsd  %xmm0,%xmm0
subsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x130(%rsp),%rdx
je     23e0 <nel_min+0x12a0>
mov    0x160(%rsp),%rax
lea    (%rax,%rsi,8),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    2340 <nel_min+0x1200>
jmp    23e0 <nel_min+0x12a0>
mov    0x58(%rsp),%rax
lea    (%rax,%rsi,8),%rcx
xor    %edx,%edx
mov    0x188(%rsp),%rax
nopl   0x0(%rax)
movupd (%r15,%rdx,1),%xmm0
movupd 0x10(%r15,%rdx,1),%xmm1
movupd -0x10(%rcx,%rdx,1),%xmm2
movupd (%rcx,%rdx,1),%xmm3
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rdx,1)
movupd %xmm1,0x10(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    2390 <nel_min+0x1250>
mov    0x50(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r9,%rcx
jne    22ed <nel_min+0x11ad>
nopl   (%rax)
mov    %r10,%r15
mov    %r11d,%esi
mov    %r11,%rbp
call   *0x88(%rsp)
movsd  0x90(%rsp),%xmm9
ucomisd %xmm0,%xmm9
movapd %xmm0,0x140(%rsp)
jbe    2450 <nel_min+0x1310>
test   %ebp,%ebp
mov    %rbp,%rsi
jle    24ac <nel_min+0x136c>
cmp    $0x4,%esi
setb   %al
or     0x66(%rsp),%al
mov    0x48(%rsp),%rdi
je     24e9 <nel_min+0x13a9>
xor    %ecx,%ecx
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rbx
mov    0xe0(%rsp),%rbp
jmp    25d9 <nel_min+0x1499>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %r14d,%r10
test   %ebp,%ebp
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    %rbp,%r11
mov    0x168(%rsp),%rsi
movsd  0x2b91(%rip),%xmm3
movapd 0x2bc0(%rip),%xmm8
mov    0x48(%rsp),%rdi
mov    %r10,0x10(%rsp)
js     27c3 <nel_min+0x1683>
movapd %xmm0,%xmm10
cmpl   $0x4,0x114(%rsp)
04
jae    26a1 <nel_min+0x1561>
xor    %eax,%eax
xor    %edx,%edx
jmp    27a0 <nel_min+0x1660>
mov    0x48(%rsp),%rdi
call   *0x88(%rsp)
movapd 0x140(%rsp),%xmm10
movsd  0x90(%rsp),%xmm9
mov    0xc8(%rsp),%r11
ucomisd %xmm0,%xmm10
mov    0x28(%rsp),%r9
ja     34f0 <nel_min+0x23b0>
jmp    3350 <nel_min+0x2210>
cmpq   $0x0,0x68(%rsp)
je     299d <nel_min+0x185d>
mov    0x208(%rsp),%rcx
xor    %eax,%eax
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rbx
mov    0xe0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm0
movupd 0x30(%rdx,%rax,8),%xmm1
movupd 0x20(%rbp,%rax,8),%xmm2
movupd 0x30(%rbp,%rax,8),%xmm3
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
movupd %xmm0,0x20(%rdi,%rax,8)
movupd %xmm1,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2520 <nel_min+0x13e0>
testb  $0x1,0x80(%rsp)
01
je     25cc <nel_min+0x148c>
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
movupd 0x0(%rbp,%rax,8),%xmm2
movupd 0x10(%rbp,%rax,8),%xmm3
addpd  %xmm0,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm1
subpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mov    0x50(%rsp),%rax
mov    %rax,%rcx
cmp    %rbx,%rax
je     2643 <nel_min+0x1503>
mov    %rcx,%rax
test   $0x1,%bl
je     25fc <nel_min+0x14bc>
movsd  (%rdx,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
subsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x130(%rsp),%rcx
je     2643 <nel_min+0x1503>
nopl   0x0(%rax)
movsd  (%rdx,%rax,8),%xmm0
addsd  %xmm0,%xmm0
subsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    2610 <nel_min+0x14d0>
mov    %rsi,%rbx
call   *0x88(%rsp)
movapd 0x140(%rsp),%xmm10
ucomisd %xmm0,%xmm10
jbe    28b8 <nel_min+0x1778>
test   %ebx,%ebx
mov    %rbx,%r11
jle    29c4 <nel_min+0x1884>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jae    29f5 <nel_min+0x18b5>
xor    %ecx,%ecx
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x20(%rsp),%r8
movsd  0x90(%rsp),%xmm9
mov    0x48(%rsp),%rbp
jmp    3460 <nel_min+0x2320>
movapd %xmm10,%xmm1
unpcklpd %xmm10,%xmm1
cmpq   $0x0,0x218(%rsp)
je     29d8 <nel_min+0x1898>
xorpd  %xmm0,%xmm0
mov    0x200(%rsp),%rcx
xor    %eax,%eax
xorpd  %xmm2,%xmm2
nopl   0x0(%rax)
movupd (%r9,%rax,8),%xmm3
movupd 0x10(%r9,%rax,8),%xmm4
movupd 0x20(%r9,%rax,8),%xmm5
movupd 0x30(%r9,%rax,8),%xmm6
movapd %xmm1,%xmm7
cmpltpd %xmm3,%xmm7
shufps $0xe8,%xmm7,%xmm7
psubd  %xmm7,%xmm0
movapd %xmm1,%xmm3
cmpltpd %xmm4,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm2
movapd %xmm1,%xmm3
cmpltpd %xmm5,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm0
movapd %xmm1,%xmm3
cmpltpd %xmm6,%xmm3
shufps $0xe8,%xmm3,%xmm3
psubd  %xmm3,%xmm2
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    26d0 <nel_min+0x1590>
testb  $0x1,0x210(%rsp)
01
je     276e <nel_min+0x162e>
movupd (%r9,%rax,8),%xmm3
movupd 0x10(%r9,%rax,8),%xmm4
movapd %xmm1,%xmm5
cmpltpd %xmm3,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm0
cmpltpd %xmm4,%xmm1
shufps $0xe8,%xmm1,%xmm1
psubd  %xmm1,%xmm2
paddd  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
mov    0x1a0(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
movsd  0x2873(%rip),%xmm3
je     27bb <nel_min+0x167b>
nopw   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm0
xor    %ecx,%ecx
ucomisd %xmm10,%xmm0
seta   %cl
add    %ecx,%edx
add    $0x1,%rax
cmp    %rax,%rsi
jne    27a0 <nel_min+0x1660>
test   %edx,%edx
jne    35f8 <nel_min+0x24b8>
test   %r11d,%r11d
mov    0x188(%rsp),%rsi
mov    0xe0(%rsp),%rbp
jle    2ab0 <nel_min+0x1970>
mov    %r15,%r8
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jb     2814 <nel_min+0x16d4>
lea    (%r8,%rax,8),%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
cmp    %rdx,%rdi
setb   %dl
cmp    0x120(%rsp),%rcx
setb   %cl
and    %dl,%cl
or     0x1f(%rsp),%cl
je     2a3e <nel_min+0x18fe>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     2846 <nel_min+0x1706>
lea    (%rdx,%rax,1),%rcx
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x130(%rsp),%rdx
je     2ab0 <nel_min+0x1970>
mov    0x160(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    2870 <nel_min+0x1730>
jmp    2ab0 <nel_min+0x1970>
test   %ebx,%ebx
mov    0x38(%rsp),%rbp
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%r8
mov    %rbx,%r11
mov    0x20(%rsp),%rdi
movsd  0x90(%rsp),%xmm9
jle    3350 <nel_min+0x2210>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jb     2910 <nel_min+0x17d0>
lea    (%r15,%rax,8),%rcx
cmp    0x158(%rsp),%rcx
jae    3119 <nel_min+0x1fd9>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    3119 <nel_min+0x1fd9>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
test   $0x3,%r8b
je     2945 <nel_min+0x1805>
lea    (%r15,%rax,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    2930 <nel_min+0x17f0>
cmp    $0x3,%rdx
jb     3350 <nel_min+0x2210>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    2960 <nel_min+0x1820>
jmp    3350 <nel_min+0x2210>
xor    %eax,%eax
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rbx
mov    0xe0(%rsp),%rbp
testb  $0x1,0x80(%rsp)
01
jne    259a <nel_min+0x145a>
jmp    25cc <nel_min+0x148c>
mov    0x28(%rsp),%r9
movsd  0x90(%rsp),%xmm9
jmp    34f0 <nel_min+0x23b0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm2,%xmm2
testb  $0x1,0x210(%rsp)
01
jne    2743 <nel_min+0x1603>
jmp    276e <nel_min+0x162e>
lea    (%r15,%rax,8),%rcx
cmp    0x120(%rsp),%rcx
mov    0x48(%rsp),%rbp
jae    312c <nel_min+0x1fec>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    312c <nel_min+0x1fec>
xor    %ecx,%ecx
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x20(%rsp),%r8
movsd  0x90(%rsp),%xmm9
jmp    3460 <nel_min+0x2320>
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd 0x0(%rbp,%rdx,1),%xmm2
movupd 0x10(%rbp,%rdx,1),%xmm3
mulpd  %xmm8,%xmm2
mulpd  %xmm8,%xmm3
mulpd  %xmm8,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm8,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rdx,1)
movupd %xmm1,0x10(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2a50 <nel_min+0x1910>
mov    0x50(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
movsd  0x255e(%rip),%xmm3
jne    2816 <nel_min+0x16d6>
mov    %r11d,%esi
mov    %r11,%rbp
call   *0x88(%rsp)
mov    0x28(%rsp),%r9
mov    0x10(%rsp),%r10
movsd  (%r9,%r10,8),%xmm1
ucomisd %xmm0,%xmm1
jae    2d05 <nel_min+0x1bc5>
test   %ebp,%ebp
mov    0xf0(%rsp),%r10
mov    %rbp,%r11
js     2dfc <nel_min+0x1cbc>
mov    0x160(%rsp),%rbx
mov    0x58(%rsp),%rbp
xor    %r15d,%r15d
jmp    2b3d <nel_min+0x19fd>
nopl   0x0(%rax)
mov    %r11d,%esi
call   *0x88(%rsp)
mov    0xc8(%rsp),%r11
mov    0xf0(%rsp),%r10
mov    0x28(%rsp),%r9
movsd  %xmm0,(%r9,%r15,8)
add    $0x1,%r15
add    %r12,%rbp
add    %r12,%rbx
cmp    0x168(%rsp),%r15
je     2dfc <nel_min+0x1cbc>
test   %r11d,%r11d
mov    0x1a8(%rsp),%rdi
mov    0x8(%rsp),%rax
movsd  0x24b3(%rip),%xmm2
movapd 0x24e3(%rip),%xmm3
jle    2b00 <nel_min+0x19c0>
mov    %r15,%r9
imul   0x108(%rsp),%r9
cmp    $0x1,%r11d
je     2bb8 <nel_min+0x1a78>
lea    (%r9,%rax,1),%rcx
mov    0x30(%rsp),%rsi
lea    (%rsi,%r9,8),%rdx
lea    (%rsi,%rcx,8),%rsi
cmp    0x258(%rsp),%rdx
setb   %r8b
cmp    %rsi,%rdi
setb   %cl
and    %r8b,%cl
cmp    0x198(%rsp),%rdx
setb   %r8b
cmp    %rsi,%r10
setb   %dl
and    %r8b,%dl
or     %cl,%dl
or     0x67(%rsp),%dl
je     2c44 <nel_min+0x1b04>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%al
je     2beb <nel_min+0x1aab>
add    %rdx,%r9
mov    0x30(%rsp),%rcx
movsd  (%rcx,%r9,8),%xmm0
addsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%r9,8)
movsd  %xmm0,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x130(%rsp),%rdx
je     2b00 <nel_min+0x19c0>
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rcx,8),%xmm0
addsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,-0x8(%rbx,%rcx,8)
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm0
addsd  0x8(%r10,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  %xmm0,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    2c00 <nel_min+0x1ac0>
jmp    2b00 <nel_min+0x19c0>
cmpq   $0x0,0x240(%rsp)
je     2cf7 <nel_min+0x1bb7>
mov    0x220(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
movupd -0x10(%rbp,%rcx,8),%xmm0
movupd (%r10,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm1,-0x10(%rbp,%rcx,8)
movupd %xmm1,(%rdi,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%r10,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm1,0x0(%rbp,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2c60 <nel_min+0x1b20>
testb  $0x1,0x238(%rsp)
01
je     2cde <nel_min+0x1b9e>
lea    (%rcx,%r9,1),%rdx
mov    0x30(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm0
movupd (%r10,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
mulpd  0x236c(%rip),%xmm1
movupd %xmm1,(%rsi,%rdx,8)
movupd %xmm1,(%rdi,%rcx,8)
mov    0x248(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
je     2b00 <nel_min+0x19c0>
jmp    2bba <nel_min+0x1a7a>
xor    %ecx,%ecx
testb  $0x1,0x238(%rsp)
jne    2cb4 <nel_min+0x1b74>
jmp    2cde <nel_min+0x1b9e>
test   %ebp,%ebp
mov    0x38(%rsp),%r8
mov    0x8(%rsp),%rbx
mov    %rbp,%r11
movsd  0x22ec(%rip),%xmm3
movapd 0x231b(%rip),%xmm8
movsd  0x90(%rsp),%xmm9
mov    0x48(%rsp),%rdi
movapd 0x140(%rsp),%xmm10
jle    35f0 <nel_min+0x24b0>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jb     2d73 <nel_min+0x1c33>
lea    (%r15,%rax,8),%rcx
cmp    0x120(%rsp),%rcx
jae    315d <nel_min+0x201d>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%rdi
jae    315d <nel_min+0x201d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     2da4 <nel_min+0x1c64>
lea    (%r15,%rax,8),%rsi
mov    0x20(%rsp),%rbp
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbp
jne    2d90 <nel_min+0x1c50>
cmp    $0x3,%rdx
jb     35f0 <nel_min+0x24b0>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,-0x18(%rax,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm1
movsd  %xmm1,-0x10(%rax,%rcx,8)
movsd  0x10(%rdi,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rcx,8)
movsd  0x18(%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    2dc0 <nel_min+0x1c80>
jmp    35f0 <nel_min+0x24b0>
movsd  (%r9),%xmm9
test   %r11d,%r11d
mov    0x8(%rsp),%rbx
movsd  0x21f7(%rip),%xmm3
movapd 0x2226(%rip),%xmm8
jle    2e4c <nel_min+0x1d0c>
cmpq   $0x3,0x190(%rsp)
jae    2e67 <nel_min+0x1d27>
xor    %edx,%edx
mov    $0x1,%eax
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r8
mov    0x20(%rsp),%rdi
movapd 0x140(%rsp),%xmm10
jmp    2f04 <nel_min+0x1dc4>
xor    %edx,%edx
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r8
movapd 0x140(%rsp),%xmm10
jmp    2f42 <nel_min+0x1e02>
xor    %edx,%edx
mov    $0x1,%eax
xor    %ecx,%ecx
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r8
mov    0x20(%rsp),%rdi
mov    0x100(%rsp),%rbp
movapd 0x140(%rsp),%xmm10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm0
ucomisd %xmm0,%xmm9
cmova  %eax,%edx
movsd  0x8(%r9,%rax,8),%xmm1
minsd  %xmm9,%xmm0
ucomisd %xmm1,%xmm0
mov    %rdx,%rsi
lea    0x1(%rax),%edx
cmovbe %esi,%edx
minsd  %xmm0,%xmm1
movsd  0x10(%r9,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
lea    0x2(%rax),%esi
cmovbe %edx,%esi
minsd  %xmm1,%xmm0
movsd  0x18(%r9,%rax,8),%xmm9
ucomisd %xmm9,%xmm0
lea    0x3(%rax),%edx
cmovbe %esi,%edx
minsd  %xmm0,%xmm9
add    $0x4,%rax
add    $0x4,%rcx
cmp    %rbp,%rcx
jne    2ea0 <nel_min+0x1d60>
testb  $0x3,0x118(%rsp)
03
je     2f42 <nel_min+0x1e02>
mov    %rdi,%rcx
movapd %xmm9,%xmm0
cs nopw 0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm9
ucomisd %xmm9,%xmm0
cmova  %eax,%edx
minsd  %xmm0,%xmm9
add    $0x1,%rax
movapd %xmm9,%xmm0
add    $0xffffffffffffffff,%rcx
jne    2f20 <nel_min+0x1de0>
test   %r11d,%r11d
jle    3100 <nel_min+0x1fc0>
mov    %edx,%eax
imul   %r11d,%eax
movslq %eax,%rcx
cmp    $0x4,%r11d
mov    %rdx,0xc0(%rsp)
jb     2f86 <nel_min+0x1e46>
mov    0x78(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
cmp    %rdx,%r10
jae    3170 <nel_min+0x2030>
lea    (%r15,%rcx,8),%rdx
cmp    0x198(%rsp),%rdx
jae    3170 <nel_min+0x2030>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rbx,%rdi
test   $0x3,%bl
je     2fb5 <nel_min+0x1e75>
lea    (%r15,%rcx,8),%rdx
mov    0x20(%rsp),%rbp
nop
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%r10,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    2fa0 <nel_min+0x1e60>
xor    %edx,%edx
cmp    $0x3,%rdi
jb     300b <nel_min+0x1ecb>
mov    0xb8(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
nopl   0x0(%rax)
movsd  -0x18(%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%r10,%rsi,8)
movsd  -0x10(%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x8(%r10,%rsi,8)
movsd  -0x8(%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x10(%r10,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x18(%r10,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    2fd0 <nel_min+0x1e90>
mov    0x30(%rsp),%r15
mov    0x48(%rsp),%rdi
mov    0x10(%rsp),%r10
cmp    $0x1,%edx
je     3605 <nel_min+0x24c5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x1,%edx
jbe    3c84 <nel_min+0x2b44>
test   %r11d,%r11d
mov    0x20(%rsp),%rdi
jle    3260 <nel_min+0x2120>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jb     3076 <nel_min+0x1f36>
lea    (%r15,%rax,8),%rcx
cmp    0x158(%rsp),%rcx
jae    310a <nel_min+0x1fca>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%r8
jae    310a <nel_min+0x1fca>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     30a5 <nel_min+0x1f65>
lea    (%r15,%rax,8),%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    3090 <nel_min+0x1f50>
cmp    $0x3,%rdx
jb     3260 <nel_min+0x2120>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  0x10(%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  0x18(%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    30c0 <nel_min+0x1f80>
jmp    3260 <nel_min+0x2120>
mov    0x10(%rsp),%r10
jmp    3c8c <nel_min+0x2b4c>
cmpq   $0xc,0x68(%rsp)
jae    3183 <nel_min+0x2043>
xor    %ecx,%ecx
jmp    3204 <nel_min+0x20c4>
cmpq   $0xc,0x68(%rsp)
jae    326b <nel_min+0x212b>
xor    %ecx,%ecx
jmp    32ed <nel_min+0x21ad>
cmpq   $0xc,0x68(%rsp)
jae    335e <nel_min+0x221e>
xor    %ecx,%ecx
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x20(%rsp),%r8
mov    0x70(%rsp),%rdi
movsd  0x90(%rsp),%xmm9
jmp    33fd <nel_min+0x22bd>
cmpq   $0xc,0x68(%rsp)
jae    350b <nel_min+0x23cb>
xor    %ecx,%ecx
jmp    358c <nel_min+0x244c>
cmpq   $0xc,0x68(%rsp)
jae    392c <nel_min+0x27ec>
xor    %edx,%edx
jmp    39b4 <nel_min+0x2874>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r8,%rcx,8),%xmm0
movups 0x10(%r8,%rcx,8),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,8)
movups %xmm1,-0x60(%rdx,%rcx,8)
movups 0x20(%r8,%rcx,8),%xmm0
movups 0x30(%r8,%rcx,8),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,8)
movups %xmm1,-0x40(%rdx,%rcx,8)
movups 0x40(%r8,%rcx,8),%xmm0
movups 0x50(%r8,%rcx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movupd 0x60(%r8,%rcx,8),%xmm0
movupd 0x70(%r8,%rcx,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm1,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    31a0 <nel_min+0x2060>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rbp
je     324f <nel_min+0x210f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x178(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    3230 <nel_min+0x20f0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
jne    3078 <nel_min+0x1f38>
movsd  %xmm10,(%r9,%r10,8)
jmp    34fe <nel_min+0x23be>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,8),%xmm0
movups 0x10(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,8)
movups %xmm1,-0x60(%rdx,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm0
movups 0x30(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,8)
movups %xmm1,-0x40(%rdx,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm0
movups 0x50(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm0
movupd 0x70(%rbp,%rcx,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm1,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    3290 <nel_min+0x2150>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rbx
je     333f <nel_min+0x21ff>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x178(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    3320 <nel_min+0x21e0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r8,%rdx
jne    2912 <nel_min+0x17d2>
movslq %r14d,%rax
movsd  %xmm10,(%r9,%rax,8)
jmp    34fe <nel_min+0x23be>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x20(%rsp),%r8
mov    0x70(%rsp),%rdi
movsd  0x90(%rsp),%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x0(%rbp,%rcx,8),%xmm1
movups 0x10(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x70(%rdx,%rcx,8)
movups %xmm2,-0x60(%rdx,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm1
movups 0x30(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x50(%rdx,%rcx,8)
movups %xmm2,-0x40(%rdx,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm1
movups 0x50(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x30(%rdx,%rcx,8)
movups %xmm2,-0x20(%rdx,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm1
movupd 0x70(%rbp,%rcx,8),%xmm2
movupd %xmm1,-0x10(%rdx,%rcx,8)
movupd %xmm2,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    33a0 <nel_min+0x2260>
testb  $0x3,0x80(%rsp)
03
je     344f <nel_min+0x230f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x170(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    3430 <nel_min+0x22f0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
je     34f0 <nel_min+0x23b0>
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     3495 <nel_min+0x2355>
lea    (%r15,%rax,8),%rsi
mov    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    3480 <nel_min+0x2340>
cmp    $0x3,%rdx
jb     34f0 <nel_min+0x23b0>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x18(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x10(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    34b0 <nel_min+0x2370>
nopl   0x0(%rax,%rax,1)
movslq %r14d,%rax
movsd  %xmm0,(%r9,%rax,8)
movapd %xmm0,%xmm10
mov    0xc0(%rsp),%rdx
jmp    3c92 <nel_min+0x2b52>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rcx,8),%xmm1
movups 0x10(%rdi,%rcx,8),%xmm2
movups %xmm1,-0x70(%rdx,%rcx,8)
movups %xmm2,-0x60(%rdx,%rcx,8)
movups 0x20(%rdi,%rcx,8),%xmm1
movups 0x30(%rdi,%rcx,8),%xmm2
movups %xmm1,-0x50(%rdx,%rcx,8)
movups %xmm2,-0x40(%rdx,%rcx,8)
movups 0x40(%rdi,%rcx,8),%xmm1
movups 0x50(%rdi,%rcx,8),%xmm2
movups %xmm1,-0x30(%rdx,%rcx,8)
movups %xmm2,-0x20(%rdx,%rcx,8)
movupd 0x60(%rdi,%rcx,8),%xmm1
movupd 0x70(%rdi,%rcx,8),%xmm2
movupd %xmm1,-0x10(%rdx,%rcx,8)
movupd %xmm2,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    3530 <nel_min+0x23f0>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rbp
je     35df <nel_min+0x249f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x170(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    35c0 <nel_min+0x2480>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
jne    2d75 <nel_min+0x1c35>
movsd  %xmm0,(%r9,%r10,8)
xor    %edx,%edx
mov    0x40(%rsp),%eax
cmp    $0x1,%edx
jne    3030 <nel_min+0x1ef0>
test   %r11d,%r11d
mov    0x188(%rsp),%rsi
mov    0xe0(%rsp),%rbp
jle    3750 <nel_min+0x2610>
cltq
cmp    $0x4,%r11d
jb     3650 <nel_min+0x2510>
lea    (%r15,%rax,8),%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
cmp    %rdx,%rdi
setb   %dl
cmp    0x120(%rsp),%rcx
setb   %cl
and    %dl,%cl
or     0x1f(%rsp),%cl
je     36e5 <nel_min+0x25a5>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%bl
je     3682 <nel_min+0x2542>
lea    (%rdx,%rax,1),%rcx
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x130(%rsp),%rdx
je     3750 <nel_min+0x2610>
mov    0x160(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    36a0 <nel_min+0x2560>
jmp    3750 <nel_min+0x2610>
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
xor    %edx,%edx
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd 0x0(%rbp,%rdx,1),%xmm2
movupd 0x10(%rbp,%rdx,1),%xmm3
mulpd  %xmm8,%xmm2
mulpd  %xmm8,%xmm3
mulpd  %xmm8,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm8,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rdi,%rdx,1)
movupd %xmm1,0x10(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    36f0 <nel_min+0x25b0>
mov    0x50(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rbx,%rcx
movsd  0x18be(%rip),%xmm3
jne    3652 <nel_min+0x2512>
movsd  %xmm9,0x90(%rsp)
mov    %r11d,%esi
mov    %r11,%rbp
call   *0x88(%rsp)
movapd 0x140(%rsp),%xmm10
ucomisd %xmm0,%xmm10
jae    3875 <nel_min+0x2735>
movapd %xmm10,%xmm0
test   %ebp,%ebp
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    %rbp,%r11
mov    0x20(%rsp),%rdi
movsd  0x90(%rsp),%xmm9
mov    0x10(%rsp),%r10
jle    3c70 <nel_min+0x2b30>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
jb     37de <nel_min+0x269e>
lea    (%r15,%rax,8),%rcx
cmp    0x158(%rsp),%rcx
jae    38fc <nel_min+0x27bc>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%r8
jae    38fc <nel_min+0x27bc>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     3815 <nel_min+0x26d5>
lea    (%r15,%rax,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    3800 <nel_min+0x26c0>
movapd %xmm10,%xmm0
cmp    $0x3,%rdx
jb     3c70 <nel_min+0x2b30>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
movsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rcx,8)
movsd  0x10(%r8,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
movsd  0x18(%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    3830 <nel_min+0x26f0>
movapd %xmm10,%xmm0
jmp    3c70 <nel_min+0x2b30>
test   %ebp,%ebp
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r9
mov    %rbp,%r11
mov    0x20(%rsp),%r10
jle    38b1 <nel_min+0x2771>
movslq 0x40(%rsp),%rax
cmp    $0x4,%r11d
mov    0x8(%rsp),%rbx
jae    38ca <nel_min+0x278a>
xor    %ecx,%ecx
movsd  0x90(%rsp),%xmm9
mov    0x48(%rsp),%rbp
jmp    3bd6 <nel_min+0x2a96>
mov    0x8(%rsp),%rbx
movsd  0x90(%rsp),%xmm9
mov    0x10(%rsp),%r10
jmp    3c70 <nel_min+0x2b30>
lea    (%r15,%rax,8),%rcx
cmp    0x120(%rsp),%rcx
mov    0x48(%rsp),%rbp
jae    390f <nel_min+0x27cf>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    390f <nel_min+0x27cf>
xor    %ecx,%ecx
movsd  0x90(%rsp),%xmm9
jmp    3bd6 <nel_min+0x2a96>
cmpq   $0xc,0x68(%rsp)
jae    3a17 <nel_min+0x28d7>
xor    %ecx,%ecx
jmp    3a94 <nel_min+0x2954>
cmpq   $0xc,0x68(%rsp)
movsd  0x90(%rsp),%xmm9
jae    3afa <nel_min+0x29ba>
xor    %ecx,%ecx
jmp    3b6d <nel_min+0x2a2d>
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
mov    0xa8(%rsp),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rsi,%rdx,8),%xmm0
movups -0x60(%rsi,%rdx,8),%xmm1
movups %xmm0,(%r10,%rdx,8)
movups %xmm1,0x10(%r10,%rdx,8)
movups -0x50(%rsi,%rdx,8),%xmm0
movups -0x40(%rsi,%rdx,8),%xmm1
movups %xmm0,0x20(%r10,%rdx,8)
movups %xmm1,0x30(%r10,%rdx,8)
movups -0x30(%rsi,%rdx,8),%xmm0
movups -0x20(%rsi,%rdx,8),%xmm1
movups %xmm0,0x40(%r10,%rdx,8)
movups %xmm1,0x50(%r10,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
movupd %xmm0,0x60(%r10,%rdx,8)
movupd %xmm1,0x70(%r10,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    3950 <nel_min+0x2810>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rbp
je     39ff <nel_min+0x28bf>
mov    0x1c0(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
add    %rcx,%rdx
mov    0x58(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
nopl   (%rax)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    39e0 <nel_min+0x28a0>
xor    %edx,%edx
mov    0x50(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rbx,%rdi
je     3010 <nel_min+0x1ed0>
jmp    2f88 <nel_min+0x1e48>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
nopl   (%rax)
movups (%r8,%rcx,8),%xmm0
movups 0x10(%r8,%rcx,8),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,8)
movups %xmm1,-0x60(%rdx,%rcx,8)
movups 0x20(%r8,%rcx,8),%xmm0
movups 0x30(%r8,%rcx,8),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,8)
movups %xmm1,-0x40(%rdx,%rcx,8)
movups 0x40(%r8,%rcx,8),%xmm0
movups 0x50(%r8,%rcx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movupd 0x60(%r8,%rcx,8),%xmm0
movupd 0x70(%r8,%rcx,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rcx,8)
movupd %xmm1,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    3a30 <nel_min+0x28f0>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rbp
je     3adf <nel_min+0x299f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x178(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    3ac0 <nel_min+0x2980>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
movapd %xmm10,%xmm0
cmp    %rbx,%rdx
je     3c70 <nel_min+0x2b30>
jmp    37e0 <nel_min+0x26a0>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
movups 0x0(%rbp,%rcx,8),%xmm1
movups 0x10(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x70(%rdx,%rcx,8)
movups %xmm2,-0x60(%rdx,%rcx,8)
movups 0x20(%rbp,%rcx,8),%xmm1
movups 0x30(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x50(%rdx,%rcx,8)
movups %xmm2,-0x40(%rdx,%rcx,8)
movups 0x40(%rbp,%rcx,8),%xmm1
movups 0x50(%rbp,%rcx,8),%xmm2
movups %xmm1,-0x30(%rdx,%rcx,8)
movups %xmm2,-0x20(%rdx,%rcx,8)
movupd 0x60(%rbp,%rcx,8),%xmm1
movupd 0x70(%rbp,%rcx,8),%xmm2
movupd %xmm1,-0x10(%rdx,%rcx,8)
movupd %xmm2,(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    3b10 <nel_min+0x29d0>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rdi
je     3bbf <nel_min+0x2a7f>
lea    (%rcx,%rax,1),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    0x170(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    3ba0 <nel_min+0x2a60>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rbx,%rdx
jne    3bd6 <nel_min+0x2a96>
mov    0x10(%rsp),%r10
jmp    3c70 <nel_min+0x2b30>
mov    %rcx,%rdx
not    %rdx
add    %rbx,%rdx
test   $0x3,%bl
je     3c0d <nel_min+0x2acd>
lea    (%r15,%rax,8),%rsi
mov    %r10,%rdi
mov    0x10(%rsp),%r10
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    3bf0 <nel_min+0x2ab0>
cmp    $0x3,%rdx
jae    3c18 <nel_min+0x2ad8>
jmp    3c70 <nel_min+0x2b30>
mov    0x10(%rsp),%r10
cmp    $0x3,%rdx
jb     3c70 <nel_min+0x2b30>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x18(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x10(%rax,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    3c30 <nel_min+0x2af0>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,(%r9,%r10,8)
mov    $0x1,%edx
cmp    $0x1,%edx
ja     3039 <nel_min+0x1ef9>
mov    0xc0(%rsp),%rdx
movsd  (%r9,%r10,8),%xmm10
ucomisd %xmm10,%xmm9
cmova  %r14d,%edx
test   %r11d,%r11d
mov    %rdx,0xc0(%rsp)
movsd  %xmm9,0x90(%rsp)
movapd %xmm10,0x140(%rsp)
js     3d90 <nel_min+0x2c50>
cmpq   $0x7,0x118(%rsp)
jae    3ce0 <nel_min+0x2ba0>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x1d8(%rsp),%rdx
jmp    3d40 <nel_min+0x2c00>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x1d8(%rsp),%rdx
mov    0x228(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
addsd  (%r9,%rax,8),%xmm1
addsd  0x8(%r9,%rax,8),%xmm1
addsd  0x10(%r9,%rax,8),%xmm1
addsd  0x18(%r9,%rax,8),%xmm1
addsd  0x20(%r9,%rax,8),%xmm1
addsd  0x28(%r9,%rax,8),%xmm1
addsd  0x30(%r9,%rax,8),%xmm1
addsd  0x38(%r9,%rax,8),%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
jne    3d00 <nel_min+0x2bc0>
test   %rdx,%rdx
je     3d5e <nel_min+0x2c1e>
lea    (%r9,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
addsd  (%rax,%rcx,8),%xmm1
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    3d50 <nel_min+0x2c10>
test   %r11d,%r11d
js     3d90 <nel_min+0x2c50>
divsd  0x230(%rsp),%xmm1
cmpq   $0x3,0x118(%rsp)
movsd  %xmm1,0x40(%rsp)
xorpd  %xmm0,%xmm0
jae    3d99 <nel_min+0x2c59>
xor    %ebx,%ebx
jmp    3e75 <nel_min+0x2d35>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
jmp    3edd <nel_min+0x2d9d>
xor    %ebx,%ebx
mov    %r9,%rbp
mov    0x1a0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,0x10(%rsp)
movsd  0x0(%rbp,%rbx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0x1248(%rip),%xmm1
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rbp,%rbx,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  0x121b(%rip),%xmm1
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x10(%rbp,%rbx,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  0x11ee(%rip),%xmm1
call   1050 <pow@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x18(%rbp,%rbx,8),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  0x11c1(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x40(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x10(%rsp),%xmm0
add    $0x4,%rbx
cmp    %rbx,%r14
jne    3db0 <nel_min+0x2c70>
testb  $0x3,0x168(%rsp)
03
mov    0x1e8(%rsp),%r14
je     3edd <nel_min+0x2d9d>
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,0x10(%rsp)
movsd  (%rbx,%rbp,8),%xmm0
subsd  %xmm1,%xmm0
movsd  0x1159(%rip),%xmm1
call   1050 <pow@plt>
movsd  0x10(%rsp),%xmm0
movsd  0x40(%rsp),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %rax,%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rbp
cmp    %rbp,%r14
jne    3ea0 <nel_min+0x2d60>
ucomisd 0x113b(%rip),%xmm0
jb     3ef0 <nel_min+0x2db0>
xorps  %xmm5,%xmm5
sqrtsd %xmm0,%xmm5
jmp    3ef9 <nel_min+0x2db9>
call   1060 <sqrt@plt>
movapd %xmm0,%xmm5
mov    0x30(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0xd8(%rsp),%r9
mov    0xc8(%rsp),%r11
mov    0x100(%rsp),%rbp
movsd  0x128(%rsp),%xmm3
mov    0xd0(%rsp),%r14
mov    0xec(%rsp),%ebx
mov    0xc0(%rsp),%rdx
movsd  0x90(%rsp),%xmm2
movapd 0x140(%rsp),%xmm4
movapd %xmm5,%xmm0
andpd  0x10d7(%rip),%xmm0
movsd  0x1e0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
mov    $0x1,%eax
cmova  %eax,%ebx
ucomisd %xmm1,%xmm0
jbe    3fa5 <nel_min+0x2e65>
minsd  %xmm2,%xmm4
mov    (%r14),%eax
cmp    0xe8(%rsp),%eax
mov    0x28(%rsp),%r8
jl     2060 <nel_min+0xf20>
jmp    3faa <nel_min+0x2e6a>
nop
mov    %r15,%r10
jmp    3fb4 <nel_min+0x2e74>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%r10
jmp    3faa <nel_min+0x2e6a>
mov    0x28(%rsp),%r8
mov    %edx,%eax
imul   %r11d,%eax
mov    %eax,0x10(%rsp)
test   %r11d,%r11d
movsd  0xf8(%rsp),%xmm2
jle    42a0 <nel_min+0x3160>
movslq 0x10(%rsp),%rax
cmp    $0x4,%r11d
mov    %rdx,0xc0(%rsp)
jb     3ffd <nel_min+0x2ebd>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%r9
jae    4090 <nel_min+0x2f50>
lea    (%r10,%rax,8),%rcx
cmp    0x1f8(%rsp),%rcx
jae    4090 <nel_min+0x2f50>
xor    %ecx,%ecx
mov    0x8(%rsp),%rsi
mov    %rcx,%rdx
not    %rdx
add    %rsi,%rdx
test   $0x3,%sil
je     4035 <nel_min+0x2ef5>
lea    (%r10,%rax,8),%rsi
mov    0x20(%rsp),%rdi
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%r9,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    4020 <nel_min+0x2ee0>
cmp    $0x3,%rdx
mov    0x8(%rsp),%rsi
jb     4190 <nel_min+0x3050>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r9,%rcx,8)
movsd  -0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r9,%rcx,8)
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r9,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r9,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    4050 <nel_min+0x2f10>
jmp    4190 <nel_min+0x3050>
cmpq   $0xc,0x68(%rsp)
jae    409f <nel_min+0x2f5f>
xor    %ecx,%ecx
jmp    4124 <nel_min+0x2fe4>
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa8(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rdx,%rcx,8),%xmm0
movups -0x60(%rdx,%rcx,8),%xmm1
movups %xmm0,(%r9,%rcx,8)
movups %xmm1,0x10(%r9,%rcx,8)
movups -0x50(%rdx,%rcx,8),%xmm0
movups -0x40(%rdx,%rcx,8),%xmm1
movups %xmm0,0x20(%r9,%rcx,8)
movups %xmm1,0x30(%r9,%rcx,8)
movups -0x30(%rdx,%rcx,8),%xmm0
movups -0x20(%rdx,%rcx,8),%xmm1
movups %xmm0,0x40(%r9,%rcx,8)
movups %xmm1,0x50(%r9,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
movupd %xmm0,0x60(%r9,%rcx,8)
movupd %xmm1,0x70(%r9,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    40c0 <nel_min+0x2f80>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rdi
je     416f <nel_min+0x302f>
mov    0x1d0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
add    %rax,%rcx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
nopl   (%rax)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    4150 <nel_min+0x3010>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
mov    0x8(%rsp),%rsi
cmp    %rsi,%rdx
jne    4004 <nel_min+0x2ec4>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r11d,%r11d
jle    42a0 <nel_min+0x3160>
movapd %xmm5,0x90(%rsp)
movslq 0xc0(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
add    0x1bc(%rsp),%ebx
mov    %ebx,0xec(%rsp)
xor    %ebx,%ebx
mov    0x88(%rsp),%r15
movsd  %xmm0,0x40(%rsp)
xchg   %ax,%ax
mov    0x1b0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm1
mulsd  0xe33(%rip),%xmm1
movsd  (%r9,%rbx,8),%xmm0
movsd  %xmm1,0xf8(%rsp)
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rbx,8)
mov    %r9,%rdi
mov    %r11d,%esi
mov    %r9,%r14
mov    %r11,%rbp
call   *%r15
movsd  0x40(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     430f <nel_min+0x31cf>
movsd  (%r14,%rbx,8),%xmm0
movsd  0xf8(%rsp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
mov    %r14,%rdi
mov    %ebp,%esi
call   *%r15
movsd  0x40(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     431e <nel_min+0x31de>
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
mov    0xd8(%rsp),%r9
mov    0xc8(%rsp),%r11
jne    41d0 <nel_min+0x3090>
mov    0x28(%rsp),%r8
mov    0xd0(%rsp),%r14
movsd  0xf8(%rsp),%xmm2
mov    0x30(%rsp),%r10
mov    0xec(%rsp),%ebx
jmp    434b <nel_min+0x320b>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rdi
test   %ebx,%ebx
jne    42b1 <nel_min+0x3171>
movsd  0xd67(%rip),%xmm2
jne    42d0 <nel_min+0x3190>
movsd  0xd45(%rip),%xmm5
mov    0x8(%rsp),%rbp
je     42db <nel_min+0x319b>
jmp    1780 <nel_min+0x640>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rbp
jne    1780 <nel_min+0x640>
test   %r11d,%r11d
jle    1780 <nel_min+0x640>
cmp    $0x4,%r11d
setb   %al
or     0x64(%rsp),%al
je     4300 <nel_min+0x31c0>
xor    %eax,%eax
jmp    4450 <nel_min+0x3310>
nopl   0x0(%rax,%rax,1)
cmpq   $0xc,0x68(%rsp)
jae    4366 <nel_min+0x3226>
xor    %eax,%eax
jmp    43dd <nel_min+0x329d>
mov    0x28(%rsp),%r8
mov    %r14,%r9
xor    %ebx,%ebx
mov    %rbp,%r11
jmp    4335 <nel_min+0x31f5>
xor    %ebx,%ebx
mov    0x28(%rsp),%r8
mov    0xd8(%rsp),%r9
mov    0xc8(%rsp),%r11
mov    0xd0(%rsp),%r14
movsd  0xf8(%rsp),%xmm2
mov    0x30(%rsp),%r10
mov    0x48(%rsp),%rdi
movapd 0x90(%rsp),%xmm5
test   %ebx,%ebx
jne    42b1 <nel_min+0x3171>
jmp    42a9 <nel_min+0x3169>
mov    0xa8(%rsp),%rcx
xor    %eax,%eax
movups (%r9,%rax,8),%xmm0
movups 0x10(%r9,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
movups 0x20(%r9,%rax,8),%xmm0
movups 0x30(%r9,%rax,8),%xmm1
movups %xmm0,0x20(%r13,%rax,8)
movups %xmm1,0x30(%r13,%rax,8)
movups 0x40(%r9,%rax,8),%xmm0
movups 0x50(%r9,%rax,8),%xmm1
movups %xmm0,0x40(%r13,%rax,8)
movups %xmm1,0x50(%r13,%rax,8)
movupd 0x60(%r9,%rax,8),%xmm0
movupd 0x70(%r9,%rax,8),%xmm1
movupd %xmm0,0x60(%r13,%rax,8)
movupd %xmm1,0x70(%r13,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    4370 <nel_min+0x3230>
testb  $0x3,0x80(%rsp)
03
mov    0x70(%rsp),%rsi
je     442f <nel_min+0x32ef>
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x1d0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    4410 <nel_min+0x32d0>
mov    0x50(%rsp),%rcx
mov    %rcx,%rax
movsd  0xbd9(%rip),%xmm2
movsd  0xbb9(%rip),%xmm5
cmp    %rbp,%rcx
je     1780 <nel_min+0x640>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x3,%bpl
je     4487 <nel_min+0x3347>
mov    0x20(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    4470 <nel_min+0x3330>
movsd  0xb89(%rip),%xmm2
movsd  0xb69(%rip),%xmm5
cmp    $0x3,%rcx
jb     1780 <nel_min+0x640>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%r9,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%r9,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    44b0 <nel_min+0x3370>
movsd  0xb20(%rip),%xmm2
movsd  0xb00(%rip),%xmm5
jmp    1780 <nel_min+0x640>
mov    %r10,%rbx
mov    %rdi,%r15
test   %r11d,%r11d
mov    0x2b0(%rsp),%r10
jle    46eb <nel_min+0x35ab>
mov    %rbp,%r12
mov    0x13c(%rsp),%r9d
cmp    $0x4,%r11d
jae    4537 <nel_min+0x33f7>
xor    %ecx,%ecx
mov    %r12,%rsi
jmp    4665 <nel_min+0x3525>
mov    %r12,%rsi
lea    (%r12,%r9,1),%rcx
lea    (%rbx,%rcx,8),%rcx
cmp    %r10,%rcx
jbe    455e <nel_min+0x341e>
mov    %rbx,%rax
lea    (%r10,%rsi,8),%rcx
lea    (%rbx,%r9,8),%rdx
cmp    %rcx,%rdx
jae    455e <nel_min+0x341e>
xor    %ecx,%ecx
jmp    4665 <nel_min+0x3525>
mov    %esi,%ecx
and    $0xfffffffc,%ecx
mov    0x80(%rsp),%rdx
mov    %edx,%eax
and    $0x3,%eax
cmpq   $0xc,0x68(%rsp)
jae    457f <nel_min+0x343f>
xor    %esi,%esi
jmp    4604 <nel_min+0x34c4>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
and    %rsi,%rdx
lea    (%rbx,%r9,8),%rdi
add    $0x70,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x70(%rdi,%rsi,8),%xmm0
movups -0x60(%rdi,%rsi,8),%xmm1
movups %xmm0,(%r10,%rsi,8)
movups %xmm1,0x10(%r10,%rsi,8)
movups -0x50(%rdi,%rsi,8),%xmm0
movups -0x40(%rdi,%rsi,8),%xmm1
movups %xmm0,0x20(%r10,%rsi,8)
movups %xmm1,0x30(%r10,%rsi,8)
movups -0x30(%rdi,%rsi,8),%xmm0
movups -0x20(%rdi,%rsi,8),%xmm1
movups %xmm0,0x40(%r10,%rsi,8)
movups %xmm1,0x50(%r10,%rsi,8)
movupd -0x10(%rdi,%rsi,8),%xmm0
movupd (%rdi,%rsi,8),%xmm1
movupd %xmm0,0x60(%r10,%rsi,8)
movupd %xmm1,0x70(%r10,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    45a0 <nel_min+0x3460>
test   %rax,%rax
je     464f <nel_min+0x350f>
lea    (%r10,%rsi,8),%rdi
add    $0x10,%rdi
add    %r9,%rsi
mov    0x30(%rsp),%rbp
lea    0x10(,%rsi,8),%rsi
add    %rbp,%rsi
shl    $0x5,%rax
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rbp,1),%xmm0
movupd (%rsi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbp,1)
movupd %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rax
jne    4630 <nel_min+0x34f0>
mov    %r12,%rsi
cmp    %r12,%rcx
mov    0x30(%rsp),%rbx
mov    0x48(%rsp),%r15
je     46eb <nel_min+0x35ab>
mov    %rcx,%rdx
not    %rdx
add    %rsi,%rdx
and    $0x3,%rsi
je     4695 <nel_min+0x3555>
lea    (%rbx,%r9,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    4680 <nel_min+0x3540>
cmp    $0x3,%rdx
jb     46eb <nel_min+0x35ab>
lea    (%rbx,%r9,8),%rax
add    $0x18,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  -0x10(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r10,%rcx,8)
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r10,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r10,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r12
jne    46b0 <nel_min+0x3570>
xor    %eax,%eax
mov    0xe8(%rsp),%ecx
cmp    %ecx,(%r14)
setge  %al
lea    (%rax,%rax,2),%ebp
add    $0x1,%ebp
mov    %r8,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x1a8(%rsp),%rdi
call   1030 <free@plt>
mov    0xf0(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @nel_min(double (double*, i32)* nocapture %0, double* nocapture %1, i32 %2, double* nocapture %3, double %4, i32 %5, i32* nocapture %6, double %7, double* nocapture writeonly %8) {
%10 = add i32 %2, 1
%11 = mul i32 %2, %2
store i32 0, i32* %6
%12 = sext i32 %2 to i64
%13 = shl i32 %2, 3
%14 = mul i32 %10, %13
%15 = tail call i64 @malloc(i32 %14)
%16 = inttoptr i64 %15 to double*
%17 = shl i32 %10, 3
%18 = tail call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to double*
%20 = tail call i64 @malloc(i32 %13)
%21 = inttoptr i64 %20 to double*
%22 = inttoptr i64 %20 to i8*
%23 = tail call i64 @malloc(i32 %13)
%24 = inttoptr i64 %23 to double*
%25 = inttoptr i64 %23 to i8*
%26 = tail call i64 @malloc(i32 %13)
%27 = inttoptr i64 %26 to double*
%28 = inttoptr i64 %26 to i8*
%29 = tail call i64 @malloc(i32 %13)
%30 = inttoptr i64 %29 to double*
%31 = inttoptr i64 %29 to i8*
%32 = tail call i64 @malloc(i32 %13)
%33 = inttoptr i64 %32 to double*
%34 = inttoptr i64 %32 to i8*
%35 = tail call i64 @malloc(i32 %13)
%36 = inttoptr i64 %35 to double*
%37 = inttoptr i64 %35 to i8*
%38 = tail call i64 @malloc(i32 %13)
%39 = inttoptr i64 %38 to double*
%40 = inttoptr i64 %38 to i8*
%41 = icmp sgt i32 %2, 0
br i1 %41, label %42, label %149
42: ; preds = %9
%43 = zext i32 %2 to i64
%44 = icmp ult i32 %2, 4
br i1 %44, label %131, label %45
45: ; preds = %42
%46 = getelementptr double, double* %36, i64 %43
%47 = getelementptr double, double* %1, i64 %43
%48 = bitcast double* %47 to i8*
%49 = icmp ult i8* %37, %48
%50 = icmp ugt double* %46, %1
%51 = and i1 %49, %50
br i1 %51, label %131, label %52
52: ; preds = %45
%53 = and i64 %43, 4294967292
%54 = add nsw i64 %53, -4
%55 = lshr exact i64 %54, 2
%56 = add nuw nsw i64 %55, 1
%57 = and i64 %56, 3
%58 = icmp ult i64 %54, 12
br i1 %58, label %110, label %59
59: ; preds = %52
%60 = and i64 %56, 9223372036854775804
br label %61
61: ; preds = %61, %59
%62 = phi i64 [ 0, %59 ], [ %107, %61 ]
%63 = phi i64 [ 0, %59 ], [ %108, %61 ]
%64 = getelementptr inbounds double, double* %1, i64 %62
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = getelementptr inbounds double, double* %64, i64 2
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = getelementptr inbounds double, double* %36, i64 %62
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %66, <2 x double>* %71
%72 = getelementptr inbounds double, double* %70, i64 2
%73 = bitcast double* %72 to <2 x double>*
store <2 x double> %69, <2 x double>* %73
%74 = or i64 %62, 4
%75 = getelementptr inbounds double, double* %1, i64 %74
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = getelementptr inbounds double, double* %75, i64 2
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = getelementptr inbounds double, double* %36, i64 %74
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> %77, <2 x double>* %82
%83 = getelementptr inbounds double, double* %81, i64 2
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %80, <2 x double>* %84
%85 = or i64 %62, 8
%86 = getelementptr inbounds double, double* %1, i64 %85
%87 = bitcast double* %86 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = getelementptr inbounds double, double* %86, i64 2
%90 = bitcast double* %89 to <2 x double>*
%91 = load <2 x double>, <2 x double>* %90
%92 = getelementptr inbounds double, double* %36, i64 %85
%93 = bitcast double* %92 to <2 x double>*
store <2 x double> %88, <2 x double>* %93
%94 = getelementptr inbounds double, double* %92, i64 2
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> %91, <2 x double>* %95
%96 = or i64 %62, 12
%97 = getelementptr inbounds double, double* %1, i64 %96
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = getelementptr inbounds double, double* %97, i64 2
%101 = bitcast double* %100 to <2 x double>*
%102 = load <2 x double>, <2 x double>* %101
%103 = getelementptr inbounds double, double* %36, i64 %96
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> %99, <2 x double>* %104
%105 = getelementptr inbounds double, double* %103, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %102, <2 x double>* %106
%107 = add nuw i64 %62, 16
%108 = add nuw i64 %63, 4
%109 = icmp eq i64 %108, %60
br i1 %109, label %110, label %61
110: ; preds = %61, %52
%111 = phi i64 [ 0, %52 ], [ %107, %61 ]
%112 = icmp eq i64 %57, 0
br i1 %112, label %129, label %113
113: ; preds = %110, %113
%114 = phi i64 [ %126, %113 ], [ %111, %110 ]
%115 = phi i64 [ %127, %113 ], [ 0, %110 ]
%116 = getelementptr inbounds double, double* %1, i64 %114
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr inbounds double, double* %116, i64 2
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = getelementptr inbounds double, double* %36, i64 %114
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %118, <2 x double>* %123
%124 = getelementptr inbounds double, double* %122, i64 2
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %121, <2 x double>* %125
%126 = add nuw i64 %114, 4
%127 = add i64 %115, 1
%128 = icmp eq i64 %127, %57
br i1 %128, label %129, label %113
129: ; preds = %113, %110
%130 = icmp eq i64 %53, %43
br i1 %130, label %149, label %131
131: ; preds = %45, %42, %129
%132 = phi i64 [ 0, %45 ], [ 0, %42 ], [ %53, %129 ]
%133 = xor i64 %132, -1
%134 = add nsw i64 %133, %43
%135 = and i64 %43, 3
%136 = icmp eq i64 %135, 0
br i1 %136, label %146, label %137
137: ; preds = %131, %137
%138 = phi i64 [ %143, %137 ], [ %132, %131 ]
%139 = phi i64 [ %144, %137 ], [ 0, %131 ]
%140 = getelementptr inbounds double, double* %1, i64 %138
%141 = load double, double* %140
%142 = getelementptr inbounds double, double* %36, i64 %138
store double %141, double* %142
%143 = add nuw nsw i64 %138, 1
%144 = add i64 %139, 1
%145 = icmp eq i64 %144, %135
br i1 %145, label %146, label %137
146: ; preds = %137, %131
%147 = phi i64 [ %132, %131 ], [ %143, %137 ]
%148 = icmp ult i64 %134, 3
br i1 %148, label %149, label %441
149: ; preds = %146, %441, %129, %9
%150 = getelementptr inbounds double, double* %19, i64 %12
%151 = icmp slt i32 %2, 1
%152 = icmp slt i32 %2, 0
%153 = sitofp i32 %2 to double
%154 = sitofp i32 %10 to double
%155 = shl i32 %2, 1
%156 = zext i32 %2 to i64
%157 = zext i32 %2 to i64
%158 = zext i32 %10 to i64
%159 = zext i32 %2 to i64
%160 = zext i32 %2 to i64
%161 = zext i32 %2 to i64
%162 = zext i32 %10 to i64
%163 = zext i32 %2 to i64
%164 = zext i32 %2 to i64
%165 = zext i32 %10 to i64
%166 = zext i32 %2 to i64
%167 = zext i32 %2 to i64
%168 = zext i32 %2 to i64
%169 = zext i32 %2 to i64
%170 = zext i32 %2 to i64
%171 = zext i32 %2 to i64
%172 = zext i32 %2 to i64
%173 = zext i32 %2 to i64
%174 = zext i32 %2 to i64
%175 = zext i32 %2 to i64
%176 = zext i32 %2 to i64
%177 = zext i32 %2 to i64
%178 = getelementptr double, double* %36, i64 %156
%179 = bitcast double* %178 to i8*
%180 = getelementptr double, double* %39, i64 %156
%181 = bitcast double* %180 to i8*
%182 = getelementptr double, double* %39, i64 %156
%183 = getelementptr double, double* %16, i64 %156
%184 = getelementptr double, double* %16, i64 %156
%185 = getelementptr double, double* %27, i64 %156
%186 = getelementptr double, double* %16, i64 %156
%187 = getelementptr double, double* %24, i64 %156
%188 = getelementptr double, double* %27, i64 %156
%189 = bitcast double* %188 to i8*
%190 = getelementptr double, double* %24, i64 %156
%191 = bitcast double* %190 to i8*
%192 = getelementptr double, double* %21, i64 %156
%193 = bitcast double* %192 to i8*
%194 = getelementptr double, double* %16, i64 %156
%195 = getelementptr double, double* %24, i64 %156
%196 = getelementptr double, double* %16, i64 %156
%197 = getelementptr double, double* %24, i64 %156
%198 = getelementptr double, double* %16, i64 %156
%199 = getelementptr double, double* %27, i64 %156
%200 = getelementptr double, double* %27, i64 %156
%201 = bitcast double* %200 to i8*
%202 = getelementptr double, double* %16, i64 %156
%203 = getelementptr double, double* %21, i64 %156
%204 = bitcast double* %203 to i8*
%205 = getelementptr double, double* %33, i64 %156
%206 = getelementptr double, double* %16, i64 %156
%207 = getelementptr double, double* %30, i64 %156
%208 = bitcast double* %207 to i8*
%209 = getelementptr double, double* %33, i64 %156
%210 = bitcast double* %209 to i8*
%211 = getelementptr double, double* %16, i64 %156
%212 = getelementptr double, double* %27, i64 %156
%213 = getelementptr double, double* %27, i64 %156
%214 = bitcast double* %213 to i8*
%215 = getelementptr double, double* %16, i64 %156
%216 = getelementptr double, double* %21, i64 %156
%217 = bitcast double* %216 to i8*
%218 = getelementptr double, double* %24, i64 %156
%219 = bitcast double* %218 to i8*
%220 = getelementptr double, double* %21, i64 %156
%221 = bitcast double* %220 to i8*
%222 = getelementptr double, double* %16, i64 %156
%223 = getelementptr double, double* %33, i64 %156
%224 = getelementptr double, double* %16, i64 %156
%225 = getelementptr double, double* %36, i64 %156
%226 = getelementptr double, double* %16, i64 %156
%227 = getelementptr double, double* %36, i64 %156
%228 = and i64 %156, 4294967292
%229 = add nsw i64 %228, -4
%230 = lshr exact i64 %229, 2
%231 = add nuw nsw i64 %230, 1
%232 = add nsw i64 %165, -1
%233 = add nsw i64 %165, -2
%234 = and i64 %165, 4294967292
%235 = add nsw i64 %234, -4
%236 = lshr exact i64 %235, 2
%237 = add nuw nsw i64 %236, 1
%238 = and i64 %156, 4294967294
%239 = add nsw i64 %238, -2
%240 = lshr exact i64 %239, 1
%241 = add nuw i64 %240, 1
%242 = icmp ult i32 %2, 4
%243 = and i64 %156, 4294967292
%244 = and i64 %231, 3
%245 = icmp ult i64 %229, 12
%246 = and i64 %231, 9223372036854775804
%247 = icmp eq i64 %244, 0
%248 = icmp eq i64 %243, %156
%249 = and i64 %156, 3
%250 = icmp eq i64 %249, 0
%251 = icmp ult i32 %2, 4
%252 = and i64 %156, 4294967292
%253 = and i64 %231, 3
%254 = icmp ult i64 %229, 12
%255 = and i64 %231, 9223372036854775804
%256 = icmp eq i64 %253, 0
%257 = icmp eq i64 %252, %156
%258 = and i64 %156, 3
%259 = icmp eq i64 %258, 0
%260 = and i64 %232, 3
%261 = icmp ult i64 %233, 3
%262 = and i64 %232, -4
%263 = icmp eq i64 %260, 0
%264 = icmp ult i32 %2, 4
%265 = and i64 %156, 4294967292
%266 = and i64 %231, 3
%267 = icmp ult i64 %229, 12
%268 = and i64 %231, 9223372036854775804
%269 = icmp eq i64 %266, 0
%270 = icmp eq i64 %265, %156
%271 = and i64 %156, 3
%272 = icmp eq i64 %271, 0
%273 = and i64 %232, 3
%274 = icmp ult i64 %233, 3
%275 = and i64 %232, -4
%276 = icmp eq i64 %273, 0
%277 = and i64 %165, 3
%278 = icmp ult i64 %232, 3
%279 = and i64 %165, 4294967292
%280 = icmp eq i64 %277, 0
%281 = icmp ult i32 %2, 4
%282 = icmp ult i8* %25, %221
%283 = icmp ult i8* %22, %219
%284 = and i1 %282, %283
%285 = and i64 %156, 4294967292
%286 = icmp eq i64 %285, %156
%287 = and i64 %156, 1
%288 = icmp eq i64 %287, 0
%289 = sub nsw i64 0, %156
%290 = icmp ult i32 %10, 4
%291 = and i64 %158, 4294967292
%292 = and i64 %237, 1
%293 = icmp eq i64 %235, 0
%294 = and i64 %237, 9223372036854775806
%295 = icmp eq i64 %292, 0
%296 = icmp eq i64 %291, %158
%297 = icmp ult i32 %2, 4
%298 = icmp ult i8* %28, %217
%299 = icmp ult i8* %22, %214
%300 = and i1 %298, %299
%301 = and i64 %156, 4294967292
%302 = icmp eq i64 %301, %156
%303 = and i64 %156, 1
%304 = icmp eq i64 %303, 0
%305 = sub nsw i64 0, %156
%306 = icmp ult i32 %2, 4
%307 = and i64 %156, 4294967292
%308 = and i64 %231, 3
%309 = icmp ult i64 %229, 12
%310 = and i64 %231, 9223372036854775804
%311 = icmp eq i64 %308, 0
%312 = icmp eq i64 %307, %156
%313 = and i64 %156, 3
%314 = icmp eq i64 %313, 0
%315 = icmp eq i32 %2, 1
%316 = icmp ult i8* %31, %210
%317 = icmp ult i8* %34, %208
%318 = and i1 %316, %317
%319 = and i64 %156, 4294967294
%320 = and i64 %241, 1
%321 = icmp eq i64 %239, 0
%322 = and i64 %241, -2
%323 = icmp eq i64 %320, 0
%324 = icmp eq i64 %319, %156
%325 = and i64 %156, 1
%326 = icmp eq i64 %325, 0
%327 = sub nsw i64 0, %156
%328 = and i64 %232, 3
%329 = icmp ult i64 %233, 3
%330 = and i64 %232, -4
%331 = icmp eq i64 %328, 0
%332 = icmp ult i32 %2, 4
%333 = and i64 %156, 4294967292
%334 = and i64 %231, 3
%335 = icmp ult i64 %229, 12
%336 = and i64 %231, 9223372036854775804
%337 = icmp eq i64 %334, 0
%338 = icmp eq i64 %333, %156
%339 = and i64 %156, 3
%340 = icmp eq i64 %339, 0
%341 = icmp ult i32 %2, 4
%342 = icmp ult i8* %28, %204
%343 = icmp ult i8* %22, %201
%344 = and i1 %342, %343
%345 = and i64 %156, 4294967292
%346 = icmp eq i64 %345, %156
%347 = and i64 %156, 1
%348 = icmp eq i64 %347, 0
%349 = sub nsw i64 0, %156
%350 = icmp ult i32 %2, 4
%351 = and i64 %156, 4294967292
%352 = and i64 %231, 3
%353 = icmp ult i64 %229, 12
%354 = and i64 %231, 9223372036854775804
%355 = icmp eq i64 %352, 0
%356 = icmp eq i64 %351, %156
%357 = and i64 %156, 3
%358 = icmp eq i64 %357, 0
%359 = icmp ult i32 %2, 4
%360 = and i64 %156, 4294967292
%361 = and i64 %231, 3
%362 = icmp ult i64 %229, 12
%363 = and i64 %231, 9223372036854775804
%364 = icmp eq i64 %361, 0
%365 = icmp eq i64 %360, %156
%366 = and i64 %156, 3
%367 = icmp eq i64 %366, 0
%368 = icmp ult i32 %2, 4
%369 = and i64 %156, 4294967292
%370 = and i64 %231, 3
%371 = icmp ult i64 %229, 12
%372 = and i64 %231, 9223372036854775804
%373 = icmp eq i64 %370, 0
%374 = icmp eq i64 %369, %156
%375 = and i64 %156, 3
%376 = icmp eq i64 %375, 0
%377 = icmp ult i32 %2, 4
%378 = icmp ult i8* %28, %191
%379 = icmp ult i8* %25, %189
%380 = and i1 %378, %379
%381 = icmp ult i8* %28, %193
%382 = icmp ult i8* %22, %189
%383 = and i1 %381, %382
%384 = or i1 %380, %383
%385 = and i64 %156, 4294967292
%386 = and i64 %231, 1
%387 = icmp eq i64 %229, 0
%388 = and i64 %231, 9223372036854775806
%389 = icmp eq i64 %386, 0
%390 = icmp eq i64 %385, %156
%391 = and i64 %156, 1
%392 = icmp eq i64 %391, 0
%393 = sub nsw i64 0, %156
%394 = icmp ult i32 %2, 4
%395 = and i64 %156, 4294967292
%396 = and i64 %231, 3
%397 = icmp ult i64 %229, 12
%398 = and i64 %231, 9223372036854775804
%399 = icmp eq i64 %396, 0
%400 = icmp eq i64 %395, %156
%401 = and i64 %156, 3
%402 = icmp eq i64 %401, 0
%403 = icmp ult i32 %2, 4
%404 = and i64 %156, 4294967292
%405 = and i64 %231, 3
%406 = icmp ult i64 %229, 12
%407 = and i64 %231, 9223372036854775804
%408 = icmp eq i64 %405, 0
%409 = icmp eq i64 %404, %156
%410 = and i64 %156, 3
%411 = icmp eq i64 %410, 0
%412 = and i64 %165, 7
%413 = icmp ult i64 %232, 7
%414 = and i64 %165, 4294967288
%415 = icmp eq i64 %412, 0
%416 = and i64 %165, 3
%417 = icmp ult i64 %232, 3
%418 = and i64 %165, 4294967292
%419 = icmp eq i64 %416, 0
%420 = icmp ult i32 %2, 4
%421 = and i64 %156, 4294967292
%422 = and i64 %231, 3
%423 = icmp ult i64 %229, 12
%424 = and i64 %231, 9223372036854775804
%425 = icmp eq i64 %422, 0
%426 = icmp eq i64 %421, %156
%427 = and i64 %156, 3
%428 = icmp eq i64 %427, 0
%429 = icmp ult i32 %2, 4
%430 = icmp ult i8* %37, %181
%431 = icmp ult i8* %40, %179
%432 = and i1 %430, %431
%433 = and i64 %156, 4294967292
%434 = and i64 %231, 3
%435 = icmp ult i64 %229, 12
%436 = and i64 %231, 9223372036854775804
%437 = icmp eq i64 %434, 0
%438 = icmp eq i64 %433, %156
%439 = and i64 %156, 3
%440 = icmp eq i64 %439, 0
br label %460
441: ; preds = %146, %441
%442 = phi i64 [ %458, %441 ], [ %147, %146 ]
%443 = getelementptr inbounds double, double* %1, i64 %442
%444 = load double, double* %443
%445 = getelementptr inbounds double, double* %36, i64 %442
store double %444, double* %445
%446 = add nuw nsw i64 %442, 1
%447 = getelementptr inbounds double, double* %1, i64 %446
%448 = load double, double* %447
%449 = getelementptr inbounds double, double* %36, i64 %446
store double %448, double* %449
%450 = add nuw nsw i64 %442, 2
%451 = getelementptr inbounds double, double* %1, i64 %450
%452 = load double, double* %451
%453 = getelementptr inbounds double, double* %36, i64 %450
store double %452, double* %453
%454 = add nuw nsw i64 %442, 3
%455 = getelementptr inbounds double, double* %1, i64 %454
%456 = load double, double* %455
%457 = getelementptr inbounds double, double* %36, i64 %454
store double %456, double* %457
%458 = add nuw nsw i64 %442, 4
%459 = icmp eq i64 %458, %43
br i1 %459, label %149, label %441
460: ; preds = %149, %2943
%461 = phi double [ 1.000000e+00, %149 ], [ %2945, %2943 ]
%462 = phi i32 [ %11, %149 ], [ %2679, %2943 ]
%463 = phi double [ 1.000000e+00, %149 ], [ %2944, %2943 ]
%464 = load i32, i32* %6
%465 = icmp slt i32 %464, %5
br i1 %465, label %466, label %2947
466: ; preds = %460
br i1 %41, label %469, label %467
467: ; preds = %466
%468 = tail call double %0(double* %36, i32 %2)
store double %468, double* %150
br label %734
469: ; preds = %466
%470 = sext i32 %462 to i64
br i1 %242, label %552, label %471
471: ; preds = %469
%472 = getelementptr double, double* %16, i64 %470
%473 = getelementptr double, double* %226, i64 %470
%474 = bitcast double* %473 to i8*
%475 = icmp ult double* %472, %227
%476 = icmp ult i8* %37, %474
%477 = and i1 %475, %476
br i1 %477, label %552, label %478
478: ; preds = %471
br i1 %245, label %532, label %479
479: ; preds = %478, %479
%480 = phi i64 [ %529, %479 ], [ 0, %478 ]
%481 = phi i64 [ %530, %479 ], [ 0, %478 ]
%482 = getelementptr inbounds double, double* %36, i64 %480
%483 = bitcast double* %482 to <2 x double>*
%484 = load <2 x double>, <2 x double>* %483
%485 = getelementptr inbounds double, double* %482, i64 2
%486 = bitcast double* %485 to <2 x double>*
%487 = load <2 x double>, <2 x double>* %486
%488 = add nsw i64 %480, %470
%489 = getelementptr inbounds double, double* %16, i64 %488
%490 = bitcast double* %489 to <2 x double>*
store <2 x double> %484, <2 x double>* %490
%491 = getelementptr inbounds double, double* %489, i64 2
%492 = bitcast double* %491 to <2 x double>*
store <2 x double> %487, <2 x double>* %492
%493 = or i64 %480, 4
%494 = getelementptr inbounds double, double* %36, i64 %493
%495 = bitcast double* %494 to <2 x double>*
%496 = load <2 x double>, <2 x double>* %495
%497 = getelementptr inbounds double, double* %494, i64 2
%498 = bitcast double* %497 to <2 x double>*
%499 = load <2 x double>, <2 x double>* %498
%500 = add nsw i64 %493, %470
%501 = getelementptr inbounds double, double* %16, i64 %500
%502 = bitcast double* %501 to <2 x double>*
store <2 x double> %496, <2 x double>* %502
%503 = getelementptr inbounds double, double* %501, i64 2
%504 = bitcast double* %503 to <2 x double>*
store <2 x double> %499, <2 x double>* %504
%505 = or i64 %480, 8
%506 = getelementptr inbounds double, double* %36, i64 %505
%507 = bitcast double* %506 to <2 x double>*
%508 = load <2 x double>, <2 x double>* %507
%509 = getelementptr inbounds double, double* %506, i64 2
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = add nsw i64 %505, %470
%513 = getelementptr inbounds double, double* %16, i64 %512
%514 = bitcast double* %513 to <2 x double>*
store <2 x double> %508, <2 x double>* %514
%515 = getelementptr inbounds double, double* %513, i64 2
%516 = bitcast double* %515 to <2 x double>*
store <2 x double> %511, <2 x double>* %516
%517 = or i64 %480, 12
%518 = getelementptr inbounds double, double* %36, i64 %517
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = getelementptr inbounds double, double* %518, i64 2
%522 = bitcast double* %521 to <2 x double>*
%523 = load <2 x double>, <2 x double>* %522
%524 = add nsw i64 %517, %470
%525 = getelementptr inbounds double, double* %16, i64 %524
%526 = bitcast double* %525 to <2 x double>*
store <2 x double> %520, <2 x double>* %526
%527 = getelementptr inbounds double, double* %525, i64 2
%528 = bitcast double* %527 to <2 x double>*
store <2 x double> %523, <2 x double>* %528
%529 = add nuw i64 %480, 16
%530 = add nuw i64 %481, 4
%531 = icmp eq i64 %530, %246
br i1 %531, label %532, label %479
532: ; preds = %479, %478
%533 = phi i64 [ 0, %478 ], [ %529, %479 ]
br i1 %247, label %551, label %534
534: ; preds = %532, %534
%535 = phi i64 [ %548, %534 ], [ %533, %532 ]
%536 = phi i64 [ %549, %534 ], [ 0, %532 ]
%537 = getelementptr inbounds double, double* %36, i64 %535
%538 = bitcast double* %537 to <2 x double>*
%539 = load <2 x double>, <2 x double>* %538
%540 = getelementptr inbounds double, double* %537, i64 2
%541 = bitcast double* %540 to <2 x double>*
%542 = load <2 x double>, <2 x double>* %541
%543 = add nsw i64 %535, %470
%544 = getelementptr inbounds double, double* %16, i64 %543
%545 = bitcast double* %544 to <2 x double>*
store <2 x double> %539, <2 x double>* %545
%546 = getelementptr inbounds double, double* %544, i64 2
%547 = bitcast double* %546 to <2 x double>*
store <2 x double> %542, <2 x double>* %547
%548 = add nuw i64 %535, 4
%549 = add i64 %536, 1
%550 = icmp eq i64 %549, %244
br i1 %550, label %551, label %534
551: ; preds = %534, %532
br i1 %248, label %592, label %552
552: ; preds = %471, %469, %551
%553 = phi i64 [ 0, %471 ], [ 0, %469 ], [ %243, %551 ]
%554 = xor i64 %553, -1
%555 = add nsw i64 %554, %156
br i1 %250, label %566, label %556
556: ; preds = %552, %556
%557 = phi i64 [ %563, %556 ], [ %553, %552 ]
%558 = phi i64 [ %564, %556 ], [ 0, %552 ]
%559 = getelementptr inbounds double, double* %36, i64 %557
%560 = load double, double* %559
%561 = add nsw i64 %557, %470
%562 = getelementptr inbounds double, double* %16, i64 %561
store double %560, double* %562
%563 = add nuw nsw i64 %557, 1
%564 = add i64 %558, 1
%565 = icmp eq i64 %564, %249
br i1 %565, label %566, label %556
566: ; preds = %556, %552
%567 = phi i64 [ %553, %552 ], [ %563, %556 ]
%568 = icmp ult i64 %555, 3
br i1 %568, label %592, label %569
569: ; preds = %566, %569
%570 = phi i64 [ %590, %569 ], [ %567, %566 ]
%571 = getelementptr inbounds double, double* %36, i64 %570
%572 = load double, double* %571
%573 = add nsw i64 %570, %470
%574 = getelementptr inbounds double, double* %16, i64 %573
store double %572, double* %574
%575 = add nuw nsw i64 %570, 1
%576 = getelementptr inbounds double, double* %36, i64 %575
%577 = load double, double* %576
%578 = add nsw i64 %575, %470
%579 = getelementptr inbounds double, double* %16, i64 %578
store double %577, double* %579
%580 = add nuw nsw i64 %570, 2
%581 = getelementptr inbounds double, double* %36, i64 %580
%582 = load double, double* %581
%583 = add nsw i64 %580, %470
%584 = getelementptr inbounds double, double* %16, i64 %583
store double %582, double* %584
%585 = add nuw nsw i64 %570, 3
%586 = getelementptr inbounds double, double* %36, i64 %585
%587 = load double, double* %586
%588 = add nsw i64 %585, %470
%589 = getelementptr inbounds double, double* %16, i64 %588
store double %587, double* %589
%590 = add nuw nsw i64 %570, 4
%591 = icmp eq i64 %590, %156
br i1 %591, label %592, label %569
592: ; preds = %566, %569, %551
%593 = tail call double %0(double* %36, i32 %2)
store double %593, double* %150
br i1 %41, label %594, label %734
594: ; preds = %592, %725
%595 = phi i64 [ %732, %725 ], [ 0, %592 ]
%596 = mul i64 %595, %12
%597 = getelementptr inbounds double, double* %3, i64 %595
%598 = load double, double* %597
%599 = getelementptr inbounds double, double* %36, i64 %595
%600 = load double, double* %599
%601 = tail call double @llvm.fmuladd.f64(double %598, double %463, double %600)
store double %601, double* %599
%602 = mul nsw i64 %595, %12
br i1 %251, label %685, label %603
603: ; preds = %594
%604 = add i64 %596, %156
%605 = getelementptr double, double* %16, i64 %604
%606 = bitcast double* %605 to i8*
%607 = getelementptr double, double* %16, i64 %596
%608 = icmp ult double* %607, %225
%609 = icmp ult i8* %37, %606
%610 = and i1 %608, %609
br i1 %610, label %685, label %611
611: ; preds = %603
br i1 %254, label %665, label %612
612: ; preds = %611, %612
%613 = phi i64 [ %662, %612 ], [ 0, %611 ]
%614 = phi i64 [ %663, %612 ], [ 0, %611 ]
%615 = getelementptr inbounds double, double* %36, i64 %613
%616 = bitcast double* %615 to <2 x double>*
%617 = load <2 x double>, <2 x double>* %616
%618 = getelementptr inbounds double, double* %615, i64 2
%619 = bitcast double* %618 to <2 x double>*
%620 = load <2 x double>, <2 x double>* %619
%621 = add nsw i64 %613, %602
%622 = getelementptr inbounds double, double* %16, i64 %621
%623 = bitcast double* %622 to <2 x double>*
store <2 x double> %617, <2 x double>* %623
%624 = getelementptr inbounds double, double* %622, i64 2
%625 = bitcast double* %624 to <2 x double>*
store <2 x double> %620, <2 x double>* %625
%626 = or i64 %613, 4
%627 = getelementptr inbounds double, double* %36, i64 %626
%628 = bitcast double* %627 to <2 x double>*
%629 = load <2 x double>, <2 x double>* %628
%630 = getelementptr inbounds double, double* %627, i64 2
%631 = bitcast double* %630 to <2 x double>*
%632 = load <2 x double>, <2 x double>* %631
%633 = add nsw i64 %626, %602
%634 = getelementptr inbounds double, double* %16, i64 %633
%635 = bitcast double* %634 to <2 x double>*
store <2 x double> %629, <2 x double>* %635
%636 = getelementptr inbounds double, double* %634, i64 2
%637 = bitcast double* %636 to <2 x double>*
store <2 x double> %632, <2 x double>* %637
%638 = or i64 %613, 8
%639 = getelementptr inbounds double, double* %36, i64 %638
%640 = bitcast double* %639 to <2 x double>*
%641 = load <2 x double>, <2 x double>* %640
%642 = getelementptr inbounds double, double* %639, i64 2
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = add nsw i64 %638, %602
%646 = getelementptr inbounds double, double* %16, i64 %645
%647 = bitcast double* %646 to <2 x double>*
store <2 x double> %641, <2 x double>* %647
%648 = getelementptr inbounds double, double* %646, i64 2
%649 = bitcast double* %648 to <2 x double>*
store <2 x double> %644, <2 x double>* %649
%650 = or i64 %613, 12
%651 = getelementptr inbounds double, double* %36, i64 %650
%652 = bitcast double* %651 to <2 x double>*
%653 = load <2 x double>, <2 x double>* %652
%654 = getelementptr inbounds double, double* %651, i64 2
%655 = bitcast double* %654 to <2 x double>*
%656 = load <2 x double>, <2 x double>* %655
%657 = add nsw i64 %650, %602
%658 = getelementptr inbounds double, double* %16, i64 %657
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> %653, <2 x double>* %659
%660 = getelementptr inbounds double, double* %658, i64 2
%661 = bitcast double* %660 to <2 x double>*
store <2 x double> %656, <2 x double>* %661
%662 = add nuw i64 %613, 16
%663 = add nuw i64 %614, 4
%664 = icmp eq i64 %663, %255
br i1 %664, label %665, label %612
665: ; preds = %612, %611
%666 = phi i64 [ 0, %611 ], [ %662, %612 ]
br i1 %256, label %684, label %667
667: ; preds = %665, %667
%668 = phi i64 [ %681, %667 ], [ %666, %665 ]
%669 = phi i64 [ %682, %667 ], [ 0, %665 ]
%670 = getelementptr inbounds double, double* %36, i64 %668
%671 = bitcast double* %670 to <2 x double>*
%672 = load <2 x double>, <2 x double>* %671
%673 = getelementptr inbounds double, double* %670, i64 2
%674 = bitcast double* %673 to <2 x double>*
%675 = load <2 x double>, <2 x double>* %674
%676 = add nsw i64 %668, %602
%677 = getelementptr inbounds double, double* %16, i64 %676
%678 = bitcast double* %677 to <2 x double>*
store <2 x double> %672, <2 x double>* %678
%679 = getelementptr inbounds double, double* %677, i64 2
%680 = bitcast double* %679 to <2 x double>*
store <2 x double> %675, <2 x double>* %680
%681 = add nuw i64 %668, 4
%682 = add i64 %669, 1
%683 = icmp eq i64 %682, %253
br i1 %683, label %684, label %667
684: ; preds = %667, %665
br i1 %257, label %725, label %685
685: ; preds = %603, %594, %684
%686 = phi i64 [ 0, %603 ], [ 0, %594 ], [ %252, %684 ]
%687 = xor i64 %686, -1
%688 = add nsw i64 %687, %156
br i1 %259, label %699, label %689
689: ; preds = %685, %689
%690 = phi i64 [ %696, %689 ], [ %686, %685 ]
%691 = phi i64 [ %697, %689 ], [ 0, %685 ]
%692 = getelementptr inbounds double, double* %36, i64 %690
%693 = load double, double* %692
%694 = add nsw i64 %690, %602
%695 = getelementptr inbounds double, double* %16, i64 %694
store double %693, double* %695
%696 = add nuw nsw i64 %690, 1
%697 = add i64 %691, 1
%698 = icmp eq i64 %697, %258
br i1 %698, label %699, label %689
699: ; preds = %689, %685
%700 = phi i64 [ %686, %685 ], [ %696, %689 ]
%701 = icmp ult i64 %688, 3
br i1 %701, label %725, label %702
702: ; preds = %699, %702
%703 = phi i64 [ %723, %702 ], [ %700, %699 ]
%704 = getelementptr inbounds double, double* %36, i64 %703
%705 = load double, double* %704
%706 = add nsw i64 %703, %602
%707 = getelementptr inbounds double, double* %16, i64 %706
store double %705, double* %707
%708 = add nuw nsw i64 %703, 1
%709 = getelementptr inbounds double, double* %36, i64 %708
%710 = load double, double* %709
%711 = add nsw i64 %708, %602
%712 = getelementptr inbounds double, double* %16, i64 %711
store double %710, double* %712
%713 = add nuw nsw i64 %703, 2
%714 = getelementptr inbounds double, double* %36, i64 %713
%715 = load double, double* %714
%716 = add nsw i64 %713, %602
%717 = getelementptr inbounds double, double* %16, i64 %716
store double %715, double* %717
%718 = add nuw nsw i64 %703, 3
%719 = getelementptr inbounds double, double* %36, i64 %718
%720 = load double, double* %719
%721 = add nsw i64 %718, %602
%722 = getelementptr inbounds double, double* %16, i64 %721
store double %720, double* %722
%723 = add nuw nsw i64 %703, 4
%724 = icmp eq i64 %723, %157
br i1 %724, label %725, label %702
725: ; preds = %699, %702, %684
%726 = tail call double %0(double* %36, i32 %2)
%727 = getelementptr inbounds double, double* %19, i64 %595
store double %726, double* %727
%728 = load double, double* %597
%729 = load double, double* %599
%730 = fneg double %728
%731 = tail call double @llvm.fmuladd.f64(double %730, double %463, double %729)
store double %731, double* %599
%732 = add nuw nsw i64 %595, 1
%733 = icmp eq i64 %732, %157
br i1 %733, label %734, label %594
734: ; preds = %725, %467, %592
%735 = load double, double* %19
br i1 %151, label %792, label %736
736: ; preds = %734
br i1 %261, label %772, label %737
737: ; preds = %736, %737
%738 = phi i64 [ %769, %737 ], [ 1, %736 ]
%739 = phi i32 [ %768, %737 ], [ 0, %736 ]
%740 = phi double [ %766, %737 ], [ %735, %736 ]
%741 = phi i64 [ %770, %737 ], [ 0, %736 ]
%742 = getelementptr inbounds double, double* %19, i64 %738
%743 = load double, double* %742
%744 = fcmp olt double %743, %740
%745 = select i1 %744, double %743, double %740
%746 = trunc i64 %738 to i32
%747 = select i1 %744, i32 %746, i32 %739
%748 = add nuw nsw i64 %738, 1
%749 = getelementptr inbounds double, double* %19, i64 %748
%750 = load double, double* %749
%751 = fcmp olt double %750, %745
%752 = select i1 %751, double %750, double %745
%753 = trunc i64 %748 to i32
%754 = select i1 %751, i32 %753, i32 %747
%755 = add nuw nsw i64 %738, 2
%756 = getelementptr inbounds double, double* %19, i64 %755
%757 = load double, double* %756
%758 = fcmp olt double %757, %752
%759 = select i1 %758, double %757, double %752
%760 = trunc i64 %755 to i32
%761 = select i1 %758, i32 %760, i32 %754
%762 = add nuw nsw i64 %738, 3
%763 = getelementptr inbounds double, double* %19, i64 %762
%764 = load double, double* %763
%765 = fcmp olt double %764, %759
%766 = select i1 %765, double %764, double %759
%767 = trunc i64 %762 to i32
%768 = select i1 %765, i32 %767, i32 %761
%769 = add nuw nsw i64 %738, 4
%770 = add i64 %741, 4
%771 = icmp eq i64 %770, %262
br i1 %771, label %772, label %737
772: ; preds = %737, %736
%773 = phi double [ undef, %736 ], [ %766, %737 ]
%774 = phi i32 [ undef, %736 ], [ %768, %737 ]
%775 = phi i64 [ 1, %736 ], [ %769, %737 ]
%776 = phi i32 [ 0, %736 ], [ %768, %737 ]
%777 = phi double [ %735, %736 ], [ %766, %737 ]
br i1 %263, label %792, label %778
778: ; preds = %772, %778
%779 = phi i64 [ %789, %778 ], [ %775, %772 ]
%780 = phi i32 [ %788, %778 ], [ %776, %772 ]
%781 = phi double [ %786, %778 ], [ %777, %772 ]
%782 = phi i64 [ %790, %778 ], [ 0, %772 ]
%783 = getelementptr inbounds double, double* %19, i64 %779
%784 = load double, double* %783
%785 = fcmp olt double %784, %781
%786 = select i1 %785, double %784, double %781
%787 = trunc i64 %779 to i32
%788 = select i1 %785, i32 %787, i32 %780
%789 = add nuw nsw i64 %779, 1
%790 = add i64 %782, 1
%791 = icmp eq i64 %790, %260
br i1 %791, label %792, label %778
792: ; preds = %772, %778, %734
%793 = phi double [ %735, %734 ], [ %773, %772 ], [ %786, %778 ]
%794 = phi i32 [ 0, %734 ], [ %774, %772 ], [ %788, %778 ]
%795 = mul i32 %794, %2
br i1 %41, label %796, label %896
796: ; preds = %792
%797 = sext i32 %795 to i64
br i1 %264, label %879, label %798
798: ; preds = %796
%799 = getelementptr double, double* %16, i64 %797
%800 = getelementptr double, double* %224, i64 %797
%801 = bitcast double* %800 to i8*
%802 = icmp ult i8* %34, %801
%803 = icmp ult double* %799, %223
%804 = and i1 %802, %803
br i1 %804, label %879, label %805
805: ; preds = %798
br i1 %267, label %859, label %806
806: ; preds = %805, %806
%807 = phi i64 [ %856, %806 ], [ 0, %805 ]
%808 = phi i64 [ %857, %806 ], [ 0, %805 ]
%809 = add nsw i64 %807, %797
%810 = getelementptr inbounds double, double* %16, i64 %809
%811 = bitcast double* %810 to <2 x double>*
%812 = load <2 x double>, <2 x double>* %811
%813 = getelementptr inbounds double, double* %810, i64 2
%814 = bitcast double* %813 to <2 x double>*
%815 = load <2 x double>, <2 x double>* %814
%816 = getelementptr inbounds double, double* %33, i64 %807
%817 = bitcast double* %816 to <2 x double>*
store <2 x double> %812, <2 x double>* %817
%818 = getelementptr inbounds double, double* %816, i64 2
%819 = bitcast double* %818 to <2 x double>*
store <2 x double> %815, <2 x double>* %819
%820 = or i64 %807, 4
%821 = add nsw i64 %820, %797
%822 = getelementptr inbounds double, double* %16, i64 %821
%823 = bitcast double* %822 to <2 x double>*
%824 = load <2 x double>, <2 x double>* %823
%825 = getelementptr inbounds double, double* %822, i64 2
%826 = bitcast double* %825 to <2 x double>*
%827 = load <2 x double>, <2 x double>* %826
%828 = getelementptr inbounds double, double* %33, i64 %820
%829 = bitcast double* %828 to <2 x double>*
store <2 x double> %824, <2 x double>* %829
%830 = getelementptr inbounds double, double* %828, i64 2
%831 = bitcast double* %830 to <2 x double>*
store <2 x double> %827, <2 x double>* %831
%832 = or i64 %807, 8
%833 = add nsw i64 %832, %797
%834 = getelementptr inbounds double, double* %16, i64 %833
%835 = bitcast double* %834 to <2 x double>*
%836 = load <2 x double>, <2 x double>* %835
%837 = getelementptr inbounds double, double* %834, i64 2
%838 = bitcast double* %837 to <2 x double>*
%839 = load <2 x double>, <2 x double>* %838
%840 = getelementptr inbounds double, double* %33, i64 %832
%841 = bitcast double* %840 to <2 x double>*
store <2 x double> %836, <2 x double>* %841
%842 = getelementptr inbounds double, double* %840, i64 2
%843 = bitcast double* %842 to <2 x double>*
store <2 x double> %839, <2 x double>* %843
%844 = or i64 %807, 12
%845 = add nsw i64 %844, %797
%846 = getelementptr inbounds double, double* %16, i64 %845
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = getelementptr inbounds double, double* %846, i64 2
%850 = bitcast double* %849 to <2 x double>*
%851 = load <2 x double>, <2 x double>* %850
%852 = getelementptr inbounds double, double* %33, i64 %844
%853 = bitcast double* %852 to <2 x double>*
store <2 x double> %848, <2 x double>* %853
%854 = getelementptr inbounds double, double* %852, i64 2
%855 = bitcast double* %854 to <2 x double>*
store <2 x double> %851, <2 x double>* %855
%856 = add nuw i64 %807, 16
%857 = add nuw i64 %808, 4
%858 = icmp eq i64 %857, %268
br i1 %858, label %859, label %806
859: ; preds = %806, %805
%860 = phi i64 [ 0, %805 ], [ %856, %806 ]
br i1 %269, label %878, label %861
861: ; preds = %859, %861
%862 = phi i64 [ %875, %861 ], [ %860, %859 ]
%863 = phi i64 [ %876, %861 ], [ 0, %859 ]
%864 = add nsw i64 %862, %797
%865 = getelementptr inbounds double, double* %16, i64 %864
%866 = bitcast double* %865 to <2 x double>*
%867 = load <2 x double>, <2 x double>* %866
%868 = getelementptr inbounds double, double* %865, i64 2
%869 = bitcast double* %868 to <2 x double>*
%870 = load <2 x double>, <2 x double>* %869
%871 = getelementptr inbounds double, double* %33, i64 %862
%872 = bitcast double* %871 to <2 x double>*
store <2 x double> %867, <2 x double>* %872
%873 = getelementptr inbounds double, double* %871, i64 2
%874 = bitcast double* %873 to <2 x double>*
store <2 x double> %870, <2 x double>* %874
%875 = add nuw i64 %862, 4
%876 = add i64 %863, 1
%877 = icmp eq i64 %876, %266
br i1 %877, label %878, label %861
878: ; preds = %861, %859
br i1 %270, label %896, label %879
879: ; preds = %798, %796, %878
%880 = phi i64 [ 0, %798 ], [ 0, %796 ], [ %265, %878 ]
%881 = xor i64 %880, -1
%882 = add nsw i64 %881, %156
br i1 %272, label %893, label %883
883: ; preds = %879, %883
%884 = phi i64 [ %890, %883 ], [ %880, %879 ]
%885 = phi i64 [ %891, %883 ], [ 0, %879 ]
%886 = add nsw i64 %884, %797
%887 = getelementptr inbounds double, double* %16, i64 %886
%888 = load double, double* %887
%889 = getelementptr inbounds double, double* %33, i64 %884
store double %888, double* %889
%890 = add nuw nsw i64 %884, 1
%891 = add i64 %885, 1
%892 = icmp eq i64 %891, %271
br i1 %892, label %893, label %883
893: ; preds = %883, %879
%894 = phi i64 [ %880, %879 ], [ %890, %883 ]
%895 = icmp ult i64 %882, 3
br i1 %895, label %896, label %902
896: ; preds = %893, %902, %878, %792
%897 = tail call double @llvm.fabs.f64(double %461)
%898 = fcmp ogt double %897, %7
br i1 %898, label %899, label %2678
899: ; preds = %896
%900 = load i32, i32* %6
%901 = icmp slt i32 %900, %5
br i1 %901, label %928, label %2673
902: ; preds = %893, %902
%903 = phi i64 [ %923, %902 ], [ %894, %893 ]
%904 = add nsw i64 %903, %797
%905 = getelementptr inbounds double, double* %16, i64 %904
%906 = load double, double* %905
%907 = getelementptr inbounds double, double* %33, i64 %903
store double %906, double* %907
%908 = add nuw nsw i64 %903, 1
%909 = add nsw i64 %908, %797
%910 = getelementptr inbounds double, double* %16, i64 %909
%911 = load double, double* %910
%912 = getelementptr inbounds double, double* %33, i64 %908
store double %911, double* %912
%913 = add nuw nsw i64 %903, 2
%914 = add nsw i64 %913, %797
%915 = getelementptr inbounds double, double* %16, i64 %914
%916 = load double, double* %915
%917 = getelementptr inbounds double, double* %33, i64 %913
store double %916, double* %917
%918 = add nuw nsw i64 %903, 3
%919 = add nsw i64 %918, %797
%920 = getelementptr inbounds double, double* %16, i64 %919
%921 = load double, double* %920
%922 = getelementptr inbounds double, double* %33, i64 %918
store double %921, double* %922
%923 = add nuw nsw i64 %903, 4
%924 = icmp eq i64 %923, %159
br i1 %924, label %896, label %902
925: ; preds = %2666
%926 = load i32, i32* %6
%927 = icmp slt i32 %926, %5
br i1 %927, label %928, label %2673
928: ; preds = %899, %925
%929 = phi i32 [ %926, %925 ], [ %900, %899 ]
%930 = phi double [ %2556, %925 ], [ %793, %899 ]
%931 = phi i32 [ %2557, %925 ], [ %794, %899 ]
%932 = phi i32 [ %2671, %925 ], [ 0, %899 ]
%933 = add nsw i32 %929, 1
store i32 %933, i32* %6
br i1 %151, label %955, label %934
934: ; preds = %928
%935 = load double, double* %19
br i1 %274, label %936, label %960
936: ; preds = %960, %934
%937 = phi i32 [ undef, %934 ], [ %991, %960 ]
%938 = phi i64 [ 1, %934 ], [ %992, %960 ]
%939 = phi i32 [ 0, %934 ], [ %991, %960 ]
%940 = phi double [ %935, %934 ], [ %989, %960 ]
br i1 %276, label %955, label %941
941: ; preds = %936, %941
%942 = phi i64 [ %952, %941 ], [ %938, %936 ]
%943 = phi i32 [ %951, %941 ], [ %939, %936 ]
%944 = phi double [ %949, %941 ], [ %940, %936 ]
%945 = phi i64 [ %953, %941 ], [ 0, %936 ]
%946 = getelementptr inbounds double, double* %19, i64 %942
%947 = load double, double* %946
%948 = fcmp ogt double %947, %944
%949 = select i1 %948, double %947, double %944
%950 = trunc i64 %942 to i32
%951 = select i1 %948, i32 %950, i32 %943
%952 = add nuw nsw i64 %942, 1
%953 = add i64 %945, 1
%954 = icmp eq i64 %953, %273
br i1 %954, label %955, label %941
955: ; preds = %936, %941, %928
%956 = phi i32 [ 0, %928 ], [ %937, %936 ], [ %951, %941 ]
%957 = mul i32 %956, %2
br i1 %41, label %958, label %1128
958: ; preds = %955
%959 = sext i32 %957 to i64
br label %995
960: ; preds = %934, %960
%961 = phi i64 [ %992, %960 ], [ 1, %934 ]
%962 = phi i32 [ %991, %960 ], [ 0, %934 ]
%963 = phi double [ %989, %960 ], [ %935, %934 ]
%964 = phi i64 [ %993, %960 ], [ 0, %934 ]
%965 = getelementptr inbounds double, double* %19, i64 %961
%966 = load double, double* %965
%967 = fcmp ogt double %966, %963
%968 = select i1 %967, double %966, double %963
%969 = trunc i64 %961 to i32
%970 = select i1 %967, i32 %969, i32 %962
%971 = add nuw nsw i64 %961, 1
%972 = getelementptr inbounds double, double* %19, i64 %971
%973 = load double, double* %972
%974 = fcmp ogt double %973, %968
%975 = select i1 %974, double %973, double %968
%976 = trunc i64 %971 to i32
%977 = select i1 %974, i32 %976, i32 %970
%978 = add nuw nsw i64 %961, 2
%979 = getelementptr inbounds double, double* %19, i64 %978
%980 = load double, double* %979
%981 = fcmp ogt double %980, %975
%982 = select i1 %981, double %980, double %975
%983 = trunc i64 %978 to i32
%984 = select i1 %981, i32 %983, i32 %977
%985 = add nuw nsw i64 %961, 3
%986 = getelementptr inbounds double, double* %19, i64 %985
%987 = load double, double* %986
%988 = fcmp ogt double %987, %982
%989 = select i1 %988, double %987, double %982
%990 = trunc i64 %985 to i32
%991 = select i1 %988, i32 %990, i32 %984
%992 = add nuw nsw i64 %961, 4
%993 = add i64 %964, 4
%994 = icmp eq i64 %993, %275
br i1 %994, label %936, label %960
995: ; preds = %958, %1044
%996 = phi i64 [ 0, %958 ], [ %1052, %1044 ]
br i1 %152, label %1044, label %997
997: ; preds = %995
br i1 %278, label %1028, label %998
998: ; preds = %997, %998
%999 = phi i64 [ %1025, %998 ], [ 0, %997 ]
%1000 = phi double [ %1024, %998 ], [ 0.000000e+00, %997 ]
%1001 = phi i64 [ %1026, %998 ], [ 0, %997 ]
%1002 = mul nsw i64 %999, %12
%1003 = add nsw i64 %1002, %996
%1004 = getelementptr inbounds double, double* %16, i64 %1003
%1005 = load double, double* %1004
%1006 = fadd double %1000, %1005
%1007 = or i64 %999, 1
%1008 = mul nsw i64 %1007, %12
%1009 = add nsw i64 %1008, %996
%1010 = getelementptr inbounds double, double* %16, i64 %1009
%1011 = load double, double* %1010
%1012 = fadd double %1006, %1011
%1013 = or i64 %999, 2
%1014 = mul nsw i64 %1013, %12
%1015 = add nsw i64 %1014, %996
%1016 = getelementptr inbounds double, double* %16, i64 %1015
%1017 = load double, double* %1016
%1018 = fadd double %1012, %1017
%1019 = or i64 %999, 3
%1020 = mul nsw i64 %1019, %12
%1021 = add nsw i64 %1020, %996
%1022 = getelementptr inbounds double, double* %16, i64 %1021
%1023 = load double, double* %1022
%1024 = fadd double %1018, %1023
%1025 = add nuw nsw i64 %999, 4
%1026 = add i64 %1001, 4
%1027 = icmp eq i64 %1026, %279
br i1 %1027, label %1028, label %998
1028: ; preds = %998, %997
%1029 = phi double [ undef, %997 ], [ %1024, %998 ]
%1030 = phi i64 [ 0, %997 ], [ %1025, %998 ]
%1031 = phi double [ 0.000000e+00, %997 ], [ %1024, %998 ]
br i1 %280, label %1044, label %1032
1032: ; preds = %1028, %1032
%1033 = phi i64 [ %1041, %1032 ], [ %1030, %1028 ]
%1034 = phi double [ %1040, %1032 ], [ %1031, %1028 ]
%1035 = phi i64 [ %1042, %1032 ], [ 0, %1028 ]
%1036 = mul nsw i64 %1033, %12
%1037 = add nsw i64 %1036, %996
%1038 = getelementptr inbounds double, double* %16, i64 %1037
%1039 = load double, double* %1038
%1040 = fadd double %1034, %1039
%1041 = add nuw nsw i64 %1033, 1
%1042 = add i64 %1035, 1
%1043 = icmp eq i64 %1042, %277
br i1 %1043, label %1044, label %1032
1044: ; preds = %1028, %1032, %995
%1045 = phi double [ 0.000000e+00, %995 ], [ %1029, %1028 ], [ %1040, %1032 ]
%1046 = add nsw i64 %996, %959
%1047 = getelementptr inbounds double, double* %16, i64 %1046
%1048 = load double, double* %1047
%1049 = fsub double %1045, %1048
%1050 = fdiv double %1049, %153
%1051 = getelementptr inbounds double, double* %21, i64 %996
store double %1050, double* %1051
%1052 = add nuw nsw i64 %996, 1
%1053 = icmp eq i64 %1052, %160
br i1 %1053, label %1054, label %995
1054: ; preds = %1044
br i1 %41, label %1055, label %1128
1055: ; preds = %1054
%1056 = sext i32 %957 to i64
br i1 %281, label %1091, label %1057
1057: ; preds = %1055
%1058 = getelementptr double, double* %16, i64 %1056
%1059 = getelementptr double, double* %222, i64 %1056
%1060 = bitcast double* %1059 to i8*
%1061 = icmp ult i8* %25, %1060
%1062 = icmp ult double* %1058, %218
%1063 = and i1 %1061, %1062
%1064 = or i1 %284, %1063
br i1 %1064, label %1091, label %1065
1065: ; preds = %1057, %1065
%1066 = phi i64 [ %1088, %1065 ], [ 0, %1057 ]
%1067 = getelementptr inbounds double, double* %21, i64 %1066
%1068 = bitcast double* %1067 to <2 x double>*
%1069 = load <2 x double>, <2 x double>* %1068
%1070 = getelementptr inbounds double, double* %1067, i64 2
%1071 = bitcast double* %1070 to <2 x double>*
%1072 = load <2 x double>, <2 x double>* %1071
%1073 = add nsw i64 %1066, %1056
%1074 = getelementptr inbounds double, double* %16, i64 %1073
%1075 = bitcast double* %1074 to <2 x double>*
%1076 = load <2 x double>, <2 x double>* %1075
%1077 = getelementptr inbounds double, double* %1074, i64 2
%1078 = bitcast double* %1077 to <2 x double>*
%1079 = load <2 x double>, <2 x double>* %1078
%1080 = fneg <2 x double> %1076
%1081 = fneg <2 x double> %1079
%1082 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1069, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1080)
%1083 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1072, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1081)
%1084 = getelementptr inbounds double, double* %24, i64 %1066
%1085 = bitcast double* %1084 to <2 x double>*
store <2 x double> %1082, <2 x double>* %1085
%1086 = getelementptr inbounds double, double* %1084, i64 2
%1087 = bitcast double* %1086 to <2 x double>*
store <2 x double> %1083, <2 x double>* %1087
%1088 = add nuw i64 %1066, 4
%1089 = icmp eq i64 %1088, %285
br i1 %1089, label %1090, label %1065
1090: ; preds = %1065
br i1 %286, label %1128, label %1091
1091: ; preds = %1057, %1055, %1090
%1092 = phi i64 [ 0, %1057 ], [ 0, %1055 ], [ %285, %1090 ]
%1093 = xor i64 %1092, -1
br i1 %288, label %1104, label %1094
1094: ; preds = %1091
%1095 = getelementptr inbounds double, double* %21, i64 %1092
%1096 = load double, double* %1095
%1097 = add nsw i64 %1092, %1056
%1098 = getelementptr inbounds double, double* %16, i64 %1097
%1099 = load double, double* %1098
%1100 = fneg double %1099
%1101 = tail call double @llvm.fmuladd.f64(double %1096, double 2.000000e+00, double %1100)
%1102 = getelementptr inbounds double, double* %24, i64 %1092
store double %1101, double* %1102
%1103 = or i64 %1092, 1
br label %1104
1104: ; preds = %1094, %1091
%1105 = phi i64 [ %1092, %1091 ], [ %1103, %1094 ]
%1106 = icmp eq i64 %1093, %289
br i1 %1106, label %1128, label %1107
1107: ; preds = %1104, %1107
%1108 = phi i64 [ %1126, %1107 ], [ %1105, %1104 ]
%1109 = getelementptr inbounds double, double* %21, i64 %1108
%1110 = load double, double* %1109
%1111 = add nsw i64 %1108, %1056
%1112 = getelementptr inbounds double, double* %16, i64 %1111
%1113 = load double, double* %1112
%1114 = fneg double %1113
%1115 = tail call double @llvm.fmuladd.f64(double %1110, double 2.000000e+00, double %1114)
%1116 = getelementptr inbounds double, double* %24, i64 %1108
store double %1115, double* %1116
%1117 = add nuw nsw i64 %1108, 1
%1118 = getelementptr inbounds double, double* %21, i64 %1117
%1119 = load double, double* %1118
%1120 = add nsw i64 %1117, %1056
%1121 = getelementptr inbounds double, double* %16, i64 %1120
%1122 = load double, double* %1121
%1123 = fneg double %1122
%1124 = tail call double @llvm.fmuladd.f64(double %1119, double 2.000000e+00, double %1123)
%1125 = getelementptr inbounds double, double* %24, i64 %1117
store double %1124, double* %1125
%1126 = add nuw nsw i64 %1108, 2
%1127 = icmp eq i64 %1126, %161
br i1 %1127, label %1128, label %1107
1128: ; preds = %1104, %1107, %1090, %955, %1054
%1129 = tail call double %0(double* %24, i32 %2)
%1130 = fcmp olt double %1129, %930
br i1 %1130, label %1198, label %1131
1131: ; preds = %1128
br i1 %152, label %1581, label %1132
1132: ; preds = %1131
br i1 %290, label %1195, label %1133
1133: ; preds = %1132
%1134 = insertelement <2 x double> poison, double %1129, i64 0
%1135 = shufflevector <2 x double> %1134, <2 x double> poison, <2 x i32> zeroinitializer
%1136 = insertelement <2 x double> poison, double %1129, i64 0
%1137 = shufflevector <2 x double> %1136, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %293, label %1171, label %1138
1138: ; preds = %1133, %1138
%1139 = phi i64 [ %1168, %1138 ], [ 0, %1133 ]
%1140 = phi <2 x i32> [ %1166, %1138 ], [ zeroinitializer, %1133 ]
%1141 = phi <2 x i32> [ %1167, %1138 ], [ zeroinitializer, %1133 ]
%1142 = phi i64 [ %1169, %1138 ], [ 0, %1133 ]
%1143 = getelementptr inbounds double, double* %19, i64 %1139
%1144 = bitcast double* %1143 to <2 x double>*
%1145 = load <2 x double>, <2 x double>* %1144
%1146 = getelementptr inbounds double, double* %1143, i64 2
%1147 = bitcast double* %1146 to <2 x double>*
%1148 = load <2 x double>, <2 x double>* %1147
%1149 = fcmp ogt <2 x double> %1145, %1135
%1150 = fcmp ogt <2 x double> %1148, %1137
%1151 = zext <2 x i1> %1149 to <2 x i32>
%1152 = zext <2 x i1> %1150 to <2 x i32>
%1153 = add <2 x i32> %1140, %1151
%1154 = add <2 x i32> %1141, %1152
%1155 = or i64 %1139, 4
%1156 = getelementptr inbounds double, double* %19, i64 %1155
%1157 = bitcast double* %1156 to <2 x double>*
%1158 = load <2 x double>, <2 x double>* %1157
%1159 = getelementptr inbounds double, double* %1156, i64 2
%1160 = bitcast double* %1159 to <2 x double>*
%1161 = load <2 x double>, <2 x double>* %1160
%1162 = fcmp ogt <2 x double> %1158, %1135
%1163 = fcmp ogt <2 x double> %1161, %1137
%1164 = zext <2 x i1> %1162 to <2 x i32>
%1165 = zext <2 x i1> %1163 to <2 x i32>
%1166 = add <2 x i32> %1153, %1164
%1167 = add <2 x i32> %1154, %1165
%1168 = add nuw i64 %1139, 8
%1169 = add i64 %1142, 2
%1170 = icmp eq i64 %1169, %294
br i1 %1170, label %1171, label %1138
1171: ; preds = %1138, %1133
%1172 = phi <2 x i32> [ undef, %1133 ], [ %1166, %1138 ]
%1173 = phi <2 x i32> [ undef, %1133 ], [ %1167, %1138 ]
%1174 = phi i64 [ 0, %1133 ], [ %1168, %1138 ]
%1175 = phi <2 x i32> [ zeroinitializer, %1133 ], [ %1166, %1138 ]
%1176 = phi <2 x i32> [ zeroinitializer, %1133 ], [ %1167, %1138 ]
br i1 %295, label %1190, label %1177
1177: ; preds = %1171
%1178 = getelementptr inbounds double, double* %19, i64 %1174
%1179 = bitcast double* %1178 to <2 x double>*
%1180 = load <2 x double>, <2 x double>* %1179
%1181 = getelementptr inbounds double, double* %1178, i64 2
%1182 = bitcast double* %1181 to <2 x double>*
%1183 = load <2 x double>, <2 x double>* %1182
%1184 = fcmp ogt <2 x double> %1180, %1135
%1185 = fcmp ogt <2 x double> %1183, %1137
%1186 = zext <2 x i1> %1184 to <2 x i32>
%1187 = zext <2 x i1> %1185 to <2 x i32>
%1188 = add <2 x i32> %1175, %1186
%1189 = add <2 x i32> %1176, %1187
br label %1190
1190: ; preds = %1171, %1177
%1191 = phi <2 x i32> [ %1172, %1171 ], [ %1188, %1177 ]
%1192 = phi <2 x i32> [ %1173, %1171 ], [ %1189, %1177 ]
%1193 = add <2 x i32> %1192, %1191
%1194 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %1193)
br i1 %296, label %1578, label %1195
1195: ; preds = %1132, %1190
%1196 = phi i64 [ 0, %1132 ], [ %291, %1190 ]
%1197 = phi i32 [ 0, %1132 ], [ %1194, %1190 ]
br label %1568
1198: ; preds = %1128
br i1 %41, label %1199, label %1310
1199: ; preds = %1198
%1200 = select i1 %377, i1 true, i1 %384
br i1 %1200, label %1273, label %1201
1201: ; preds = %1199
br i1 %387, label %1249, label %1202
1202: ; preds = %1201, %1202
%1203 = phi i64 [ %1246, %1202 ], [ 0, %1201 ]
%1204 = phi i64 [ %1247, %1202 ], [ 0, %1201 ]
%1205 = getelementptr inbounds double, double* %24, i64 %1203
%1206 = bitcast double* %1205 to <2 x double>*
%1207 = load <2 x double>, <2 x double>* %1206
%1208 = getelementptr inbounds double, double* %1205, i64 2
%1209 = bitcast double* %1208 to <2 x double>*
%1210 = load <2 x double>, <2 x double>* %1209
%1211 = getelementptr inbounds double, double* %21, i64 %1203
%1212 = bitcast double* %1211 to <2 x double>*
%1213 = load <2 x double>, <2 x double>* %1212
%1214 = getelementptr inbounds double, double* %1211, i64 2
%1215 = bitcast double* %1214 to <2 x double>*
%1216 = load <2 x double>, <2 x double>* %1215
%1217 = fneg <2 x double> %1213
%1218 = fneg <2 x double> %1216
%1219 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1207, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1217)
%1220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1210, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1218)
%1221 = getelementptr inbounds double, double* %27, i64 %1203
%1222 = bitcast double* %1221 to <2 x double>*
store <2 x double> %1219, <2 x double>* %1222
%1223 = getelementptr inbounds double, double* %1221, i64 2
%1224 = bitcast double* %1223 to <2 x double>*
store <2 x double> %1220, <2 x double>* %1224
%1225 = or i64 %1203, 4
%1226 = getelementptr inbounds double, double* %24, i64 %1225
%1227 = bitcast double* %1226 to <2 x double>*
%1228 = load <2 x double>, <2 x double>* %1227
%1229 = getelementptr inbounds double, double* %1226, i64 2
%1230 = bitcast double* %1229 to <2 x double>*
%1231 = load <2 x double>, <2 x double>* %1230
%1232 = getelementptr inbounds double, double* %21, i64 %1225
%1233 = bitcast double* %1232 to <2 x double>*
%1234 = load <2 x double>, <2 x double>* %1233
%1235 = getelementptr inbounds double, double* %1232, i64 2
%1236 = bitcast double* %1235 to <2 x double>*
%1237 = load <2 x double>, <2 x double>* %1236
%1238 = fneg <2 x double> %1234
%1239 = fneg <2 x double> %1237
%1240 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1228, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1238)
%1241 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1231, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1239)
%1242 = getelementptr inbounds double, double* %27, i64 %1225
%1243 = bitcast double* %1242 to <2 x double>*
store <2 x double> %1240, <2 x double>* %1243
%1244 = getelementptr inbounds double, double* %1242, i64 2
%1245 = bitcast double* %1244 to <2 x double>*
store <2 x double> %1241, <2 x double>* %1245
%1246 = add nuw i64 %1203, 8
%1247 = add i64 %1204, 2
%1248 = icmp eq i64 %1247, %388
br i1 %1248, label %1249, label %1202
1249: ; preds = %1202, %1201
%1250 = phi i64 [ 0, %1201 ], [ %1246, %1202 ]
br i1 %389, label %1272, label %1251
1251: ; preds = %1249
%1252 = getelementptr inbounds double, double* %24, i64 %1250
%1253 = bitcast double* %1252 to <2 x double>*
%1254 = load <2 x double>, <2 x double>* %1253
%1255 = getelementptr inbounds double, double* %1252, i64 2
%1256 = bitcast double* %1255 to <2 x double>*
%1257 = load <2 x double>, <2 x double>* %1256
%1258 = getelementptr inbounds double, double* %21, i64 %1250
%1259 = bitcast double* %1258 to <2 x double>*
%1260 = load <2 x double>, <2 x double>* %1259
%1261 = getelementptr inbounds double, double* %1258, i64 2
%1262 = bitcast double* %1261 to <2 x double>*
%1263 = load <2 x double>, <2 x double>* %1262
%1264 = fneg <2 x double> %1260
%1265 = fneg <2 x double> %1263
%1266 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1254, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1264)
%1267 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1257, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %1265)
%1268 = getelementptr inbounds double, double* %27, i64 %1250
%1269 = bitcast double* %1268 to <2 x double>*
store <2 x double> %1266, <2 x double>* %1269
%1270 = getelementptr inbounds double, double* %1268, i64 2
%1271 = bitcast double* %1270 to <2 x double>*
store <2 x double> %1267, <2 x double>* %1271
br label %1272
1272: ; preds = %1249, %1251
br i1 %390, label %1307, label %1273
1273: ; preds = %1199, %1272
%1274 = phi i64 [ 0, %1199 ], [ %385, %1272 ]
%1275 = xor i64 %1274, -1
br i1 %392, label %1285, label %1276
1276: ; preds = %1273
%1277 = getelementptr inbounds double, double* %24, i64 %1274
%1278 = load double, double* %1277
%1279 = getelementptr inbounds double, double* %21, i64 %1274
%1280 = load double, double* %1279
%1281 = fneg double %1280
%1282 = tail call double @llvm.fmuladd.f64(double %1278, double 2.000000e+00, double %1281)
%1283 = getelementptr inbounds double, double* %27, i64 %1274
store double %1282, double* %1283
%1284 = or i64 %1274, 1
br label %1285
1285: ; preds = %1276, %1273
%1286 = phi i64 [ %1274, %1273 ], [ %1284, %1276 ]
%1287 = icmp eq i64 %1275, %393
br i1 %1287, label %1307, label %1288
1288: ; preds = %1285, %1288
%1289 = phi i64 [ %1305, %1288 ], [ %1286, %1285 ]
%1290 = getelementptr inbounds double, double* %24, i64 %1289
%1291 = load double, double* %1290
%1292 = getelementptr inbounds double, double* %21, i64 %1289
%1293 = load double, double* %1292
%1294 = fneg double %1293
%1295 = tail call double @llvm.fmuladd.f64(double %1291, double 2.000000e+00, double %1294)
%1296 = getelementptr inbounds double, double* %27, i64 %1289
store double %1295, double* %1296
%1297 = add nuw nsw i64 %1289, 1
%1298 = getelementptr inbounds double, double* %24, i64 %1297
%1299 = load double, double* %1298
%1300 = getelementptr inbounds double, double* %21, i64 %1297
%1301 = load double, double* %1300
%1302 = fneg double %1301
%1303 = tail call double @llvm.fmuladd.f64(double %1299, double 2.000000e+00, double %1302)
%1304 = getelementptr inbounds double, double* %27, i64 %1297
store double %1303, double* %1304
%1305 = add nuw nsw i64 %1289, 2
%1306 = icmp eq i64 %1305, %172
br i1 %1306, label %1307, label %1288
1307: ; preds = %1285, %1288, %1272
%1308 = tail call double %0(double* %27, i32 %2)
%1309 = fcmp olt double %1308, %1129
br i1 %1309, label %1414, label %1313
1310: ; preds = %1198
%1311 = tail call double %0(double* %27, i32 %2)
%1312 = fcmp olt double %1311, %1129
br i1 %1312, label %1538, label %1565
1313: ; preds = %1307
br i1 %41, label %1314, label %1565
1314: ; preds = %1313
%1315 = sext i32 %957 to i64
br i1 %394, label %1397, label %1316
1316: ; preds = %1314
%1317 = getelementptr double, double* %16, i64 %1315
%1318 = getelementptr double, double* %186, i64 %1315
%1319 = bitcast double* %1318 to i8*
%1320 = icmp ult double* %1317, %187
%1321 = icmp ult i8* %25, %1319
%1322 = and i1 %1320, %1321
br i1 %1322, label %1397, label %1323
1323: ; preds = %1316
br i1 %397, label %1377, label %1324
1324: ; preds = %1323, %1324
%1325 = phi i64 [ %1374, %1324 ], [ 0, %1323 ]
%1326 = phi i64 [ %1375, %1324 ], [ 0, %1323 ]
%1327 = getelementptr inbounds double, double* %24, i64 %1325
%1328 = bitcast double* %1327 to <2 x double>*
%1329 = load <2 x double>, <2 x double>* %1328
%1330 = getelementptr inbounds double, double* %1327, i64 2
%1331 = bitcast double* %1330 to <2 x double>*
%1332 = load <2 x double>, <2 x double>* %1331
%1333 = add nsw i64 %1325, %1315
%1334 = getelementptr inbounds double, double* %16, i64 %1333
%1335 = bitcast double* %1334 to <2 x double>*
store <2 x double> %1329, <2 x double>* %1335
%1336 = getelementptr inbounds double, double* %1334, i64 2
%1337 = bitcast double* %1336 to <2 x double>*
store <2 x double> %1332, <2 x double>* %1337
%1338 = or i64 %1325, 4
%1339 = getelementptr inbounds double, double* %24, i64 %1338
%1340 = bitcast double* %1339 to <2 x double>*
%1341 = load <2 x double>, <2 x double>* %1340
%1342 = getelementptr inbounds double, double* %1339, i64 2
%1343 = bitcast double* %1342 to <2 x double>*
%1344 = load <2 x double>, <2 x double>* %1343
%1345 = add nsw i64 %1338, %1315
%1346 = getelementptr inbounds double, double* %16, i64 %1345
%1347 = bitcast double* %1346 to <2 x double>*
store <2 x double> %1341, <2 x double>* %1347
%1348 = getelementptr inbounds double, double* %1346, i64 2
%1349 = bitcast double* %1348 to <2 x double>*
store <2 x double> %1344, <2 x double>* %1349
%1350 = or i64 %1325, 8
%1351 = getelementptr inbounds double, double* %24, i64 %1350
%1352 = bitcast double* %1351 to <2 x double>*
%1353 = load <2 x double>, <2 x double>* %1352
%1354 = getelementptr inbounds double, double* %1351, i64 2
%1355 = bitcast double* %1354 to <2 x double>*
%1356 = load <2 x double>, <2 x double>* %1355
%1357 = add nsw i64 %1350, %1315
%1358 = getelementptr inbounds double, double* %16, i64 %1357
%1359 = bitcast double* %1358 to <2 x double>*
store <2 x double> %1353, <2 x double>* %1359
%1360 = getelementptr inbounds double, double* %1358, i64 2
%1361 = bitcast double* %1360 to <2 x double>*
store <2 x double> %1356, <2 x double>* %1361
%1362 = or i64 %1325, 12
%1363 = getelementptr inbounds double, double* %24, i64 %1362
%1364 = bitcast double* %1363 to <2 x double>*
%1365 = load <2 x double>, <2 x double>* %1364
%1366 = getelementptr inbounds double, double* %1363, i64 2
%1367 = bitcast double* %1366 to <2 x double>*
%1368 = load <2 x double>, <2 x double>* %1367
%1369 = add nsw i64 %1362, %1315
%1370 = getelementptr inbounds double, double* %16, i64 %1369
%1371 = bitcast double* %1370 to <2 x double>*
store <2 x double> %1365, <2 x double>* %1371
%1372 = getelementptr inbounds double, double* %1370, i64 2
%1373 = bitcast double* %1372 to <2 x double>*
store <2 x double> %1368, <2 x double>* %1373
%1374 = add nuw i64 %1325, 16
%1375 = add nuw i64 %1326, 4
%1376 = icmp eq i64 %1375, %398
br i1 %1376, label %1377, label %1324
1377: ; preds = %1324, %1323
%1378 = phi i64 [ 0, %1323 ], [ %1374, %1324 ]
br i1 %399, label %1396, label %1379
1379: ; preds = %1377, %1379
%1380 = phi i64 [ %1393, %1379 ], [ %1378, %1377 ]
%1381 = phi i64 [ %1394, %1379 ], [ 0, %1377 ]
%1382 = getelementptr inbounds double, double* %24, i64 %1380
%1383 = bitcast double* %1382 to <2 x double>*
%1384 = load <2 x double>, <2 x double>* %1383
%1385 = getelementptr inbounds double, double* %1382, i64 2
%1386 = bitcast double* %1385 to <2 x double>*
%1387 = load <2 x double>, <2 x double>* %1386
%1388 = add nsw i64 %1380, %1315
%1389 = getelementptr inbounds double, double* %16, i64 %1388
%1390 = bitcast double* %1389 to <2 x double>*
store <2 x double> %1384, <2 x double>* %1390
%1391 = getelementptr inbounds double, double* %1389, i64 2
%1392 = bitcast double* %1391 to <2 x double>*
store <2 x double> %1387, <2 x double>* %1392
%1393 = add nuw i64 %1380, 4
%1394 = add i64 %1381, 1
%1395 = icmp eq i64 %1394, %396
br i1 %1395, label %1396, label %1379
1396: ; preds = %1379, %1377
br i1 %400, label %1565, label %1397
1397: ; preds = %1316, %1314, %1396
%1398 = phi i64 [ 0, %1316 ], [ 0, %1314 ], [ %395, %1396 ]
%1399 = xor i64 %1398, -1
%1400 = add nsw i64 %1399, %156
br i1 %402, label %1411, label %1401
1401: ; preds = %1397, %1401
%1402 = phi i64 [ %1408, %1401 ], [ %1398, %1397 ]
%1403 = phi i64 [ %1409, %1401 ], [ 0, %1397 ]
%1404 = getelementptr inbounds double, double* %24, i64 %1402
%1405 = load double, double* %1404
%1406 = add nsw i64 %1402, %1315
%1407 = getelementptr inbounds double, double* %16, i64 %1406
store double %1405, double* %1407
%1408 = add nuw nsw i64 %1402, 1
%1409 = add i64 %1403, 1
%1410 = icmp eq i64 %1409, %401
br i1 %1410, label %1411, label %1401
1411: ; preds = %1401, %1397
%1412 = phi i64 [ %1398, %1397 ], [ %1408, %1401 ]
%1413 = icmp ult i64 %1400, 3
br i1 %1413, label %1565, label %1542
1414: ; preds = %1307
br i1 %41, label %1415, label %1538
1415: ; preds = %1414
%1416 = sext i32 %957 to i64
br i1 %403, label %1498, label %1417
1417: ; preds = %1415
%1418 = getelementptr double, double* %16, i64 %1416
%1419 = getelementptr double, double* %184, i64 %1416
%1420 = bitcast double* %1419 to i8*
%1421 = icmp ult double* %1418, %185
%1422 = icmp ult i8* %28, %1420
%1423 = and i1 %1421, %1422
br i1 %1423, label %1498, label %1424
1424: ; preds = %1417
br i1 %406, label %1478, label %1425
1425: ; preds = %1424, %1425
%1426 = phi i64 [ %1475, %1425 ], [ 0, %1424 ]
%1427 = phi i64 [ %1476, %1425 ], [ 0, %1424 ]
%1428 = getelementptr inbounds double, double* %27, i64 %1426
%1429 = bitcast double* %1428 to <2 x double>*
%1430 = load <2 x double>, <2 x double>* %1429
%1431 = getelementptr inbounds double, double* %1428, i64 2
%1432 = bitcast double* %1431 to <2 x double>*
%1433 = load <2 x double>, <2 x double>* %1432
%1434 = add nsw i64 %1426, %1416
%1435 = getelementptr inbounds double, double* %16, i64 %1434
%1436 = bitcast double* %1435 to <2 x double>*
store <2 x double> %1430, <2 x double>* %1436
%1437 = getelementptr inbounds double, double* %1435, i64 2
%1438 = bitcast double* %1437 to <2 x double>*
store <2 x double> %1433, <2 x double>* %1438
%1439 = or i64 %1426, 4
%1440 = getelementptr inbounds double, double* %27, i64 %1439
%1441 = bitcast double* %1440 to <2 x double>*
%1442 = load <2 x double>, <2 x double>* %1441
%1443 = getelementptr inbounds double, double* %1440, i64 2
%1444 = bitcast double* %1443 to <2 x double>*
%1445 = load <2 x double>, <2 x double>* %1444
%1446 = add nsw i64 %1439, %1416
%1447 = getelementptr inbounds double, double* %16, i64 %1446
%1448 = bitcast double* %1447 to <2 x double>*
store <2 x double> %1442, <2 x double>* %1448
%1449 = getelementptr inbounds double, double* %1447, i64 2
%1450 = bitcast double* %1449 to <2 x double>*
store <2 x double> %1445, <2 x double>* %1450
%1451 = or i64 %1426, 8
%1452 = getelementptr inbounds double, double* %27, i64 %1451
%1453 = bitcast double* %1452 to <2 x double>*
%1454 = load <2 x double>, <2 x double>* %1453
%1455 = getelementptr inbounds double, double* %1452, i64 2
%1456 = bitcast double* %1455 to <2 x double>*
%1457 = load <2 x double>, <2 x double>* %1456
%1458 = add nsw i64 %1451, %1416
%1459 = getelementptr inbounds double, double* %16, i64 %1458
%1460 = bitcast double* %1459 to <2 x double>*
store <2 x double> %1454, <2 x double>* %1460
%1461 = getelementptr inbounds double, double* %1459, i64 2
%1462 = bitcast double* %1461 to <2 x double>*
store <2 x double> %1457, <2 x double>* %1462
%1463 = or i64 %1426, 12
%1464 = getelementptr inbounds double, double* %27, i64 %1463
%1465 = bitcast double* %1464 to <2 x double>*
%1466 = load <2 x double>, <2 x double>* %1465
%1467 = getelementptr inbounds double, double* %1464, i64 2
%1468 = bitcast double* %1467 to <2 x double>*
%1469 = load <2 x double>, <2 x double>* %1468
%1470 = add nsw i64 %1463, %1416
%1471 = getelementptr inbounds double, double* %16, i64 %1470
%1472 = bitcast double* %1471 to <2 x double>*
store <2 x double> %1466, <2 x double>* %1472
%1473 = getelementptr inbounds double, double* %1471, i64 2
%1474 = bitcast double* %1473 to <2 x double>*
store <2 x double> %1469, <2 x double>* %1474
%1475 = add nuw i64 %1426, 16
%1476 = add nuw i64 %1427, 4
%1477 = icmp eq i64 %1476, %407
br i1 %1477, label %1478, label %1425
1478: ; preds = %1425, %1424
%1479 = phi i64 [ 0, %1424 ], [ %1475, %1425 ]
br i1 %408, label %1497, label %1480
1480: ; preds = %1478, %1480
%1481 = phi i64 [ %1494, %1480 ], [ %1479, %1478 ]
%1482 = phi i64 [ %1495, %1480 ], [ 0, %1478 ]
%1483 = getelementptr inbounds double, double* %27, i64 %1481
%1484 = bitcast double* %1483 to <2 x double>*
%1485 = load <2 x double>, <2 x double>* %1484
%1486 = getelementptr inbounds double, double* %1483, i64 2
%1487 = bitcast double* %1486 to <2 x double>*
%1488 = load <2 x double>, <2 x double>* %1487
%1489 = add nsw i64 %1481, %1416
%1490 = getelementptr inbounds double, double* %16, i64 %1489
%1491 = bitcast double* %1490 to <2 x double>*
store <2 x double> %1485, <2 x double>* %1491
%1492 = getelementptr inbounds double, double* %1490, i64 2
%1493 = bitcast double* %1492 to <2 x double>*
store <2 x double> %1488, <2 x double>* %1493
%1494 = add nuw i64 %1481, 4
%1495 = add i64 %1482, 1
%1496 = icmp eq i64 %1495, %405
br i1 %1496, label %1497, label %1480
1497: ; preds = %1480, %1478
br i1 %409, label %1538, label %1498
1498: ; preds = %1417, %1415, %1497
%1499 = phi i64 [ 0, %1417 ], [ 0, %1415 ], [ %404, %1497 ]
%1500 = xor i64 %1499, -1
%1501 = add nsw i64 %1500, %156
br i1 %411, label %1512, label %1502
1502: ; preds = %1498, %1502
%1503 = phi i64 [ %1509, %1502 ], [ %1499, %1498 ]
%1504 = phi i64 [ %1510, %1502 ], [ 0, %1498 ]
%1505 = getelementptr inbounds double, double* %27, i64 %1503
%1506 = load double, double* %1505
%1507 = add nsw i64 %1503, %1416
%1508 = getelementptr inbounds double, double* %16, i64 %1507
store double %1506, double* %1508
%1509 = add nuw nsw i64 %1503, 1
%1510 = add i64 %1504, 1
%1511 = icmp eq i64 %1510, %410
br i1 %1511, label %1512, label %1502
1512: ; preds = %1502, %1498
%1513 = phi i64 [ %1499, %1498 ], [ %1509, %1502 ]
%1514 = icmp ult i64 %1501, 3
br i1 %1514, label %1538, label %1515
1515: ; preds = %1512, %1515
%1516 = phi i64 [ %1536, %1515 ], [ %1513, %1512 ]
%1517 = getelementptr inbounds double, double* %27, i64 %1516
%1518 = load double, double* %1517
%1519 = add nsw i64 %1516, %1416
%1520 = getelementptr inbounds double, double* %16, i64 %1519
store double %1518, double* %1520
%1521 = add nuw nsw i64 %1516, 1
%1522 = getelementptr inbounds double, double* %27, i64 %1521
%1523 = load double, double* %1522
%1524 = add nsw i64 %1521, %1416
%1525 = getelementptr inbounds double, double* %16, i64 %1524
store double %1523, double* %1525
%1526 = add nuw nsw i64 %1516, 2
%1527 = getelementptr inbounds double, double* %27, i64 %1526
%1528 = load double, double* %1527
%1529 = add nsw i64 %1526, %1416
%1530 = getelementptr inbounds double, double* %16, i64 %1529
store double %1528, double* %1530
%1531 = add nuw nsw i64 %1516, 3
%1532 = getelementptr inbounds double, double* %27, i64 %1531
%1533 = load double, double* %1532
%1534 = add nsw i64 %1531, %1416
%1535 = getelementptr inbounds double, double* %16, i64 %1534
store double %1533, double* %1535
%1536 = add nuw nsw i64 %1516, 4
%1537 = icmp eq i64 %1536, %174
br i1 %1537, label %1538, label %1515
1538: ; preds = %1512, %1515, %1497, %1310, %1414
%1539 = phi double [ %1308, %1414 ], [ %1311, %1310 ], [ %1308, %1497 ], [ %1308, %1515 ], [ %1308, %1512 ]
%1540 = sext i32 %956 to i64
%1541 = getelementptr inbounds double, double* %19, i64 %1540
store double %1539, double* %1541
br label %2551
1542: ; preds = %1411, %1542
%1543 = phi i64 [ %1563, %1542 ], [ %1412, %1411 ]
%1544 = getelementptr inbounds double, double* %24, i64 %1543
%1545 = load double, double* %1544
%1546 = add nsw i64 %1543, %1315
%1547 = getelementptr inbounds double, double* %16, i64 %1546
store double %1545, double* %1547
%1548 = add nuw nsw i64 %1543, 1
%1549 = getelementptr inbounds double, double* %24, i64 %1548
%1550 = load double, double* %1549
%1551 = add nsw i64 %1548, %1315
%1552 = getelementptr inbounds double, double* %16, i64 %1551
store double %1550, double* %1552
%1553 = add nuw nsw i64 %1543, 2
%1554 = getelementptr inbounds double, double* %24, i64 %1553
%1555 = load double, double* %1554
%1556 = add nsw i64 %1553, %1315
%1557 = getelementptr inbounds double, double* %16, i64 %1556
store double %1555, double* %1557
%1558 = add nuw nsw i64 %1543, 3
%1559 = getelementptr inbounds double, double* %24, i64 %1558
%1560 = load double, double* %1559
%1561 = add nsw i64 %1558, %1315
%1562 = getelementptr inbounds double, double* %16, i64 %1561
store double %1560, double* %1562
%1563 = add nuw nsw i64 %1543, 4
%1564 = icmp eq i64 %1563, %173
br i1 %1564, label %1565, label %1542
1565: ; preds = %1411, %1542, %1396, %1310, %1313
%1566 = sext i32 %956 to i64
%1567 = getelementptr inbounds double, double* %19, i64 %1566
store double %1129, double* %1567
br label %2551
1568: ; preds = %1195, %1568
%1569 = phi i64 [ %1576, %1568 ], [ %1196, %1195 ]
%1570 = phi i32 [ %1575, %1568 ], [ %1197, %1195 ]
%1571 = getelementptr inbounds double, double* %19, i64 %1569
%1572 = load double, double* %1571
%1573 = fcmp ogt double %1572, %1129
%1574 = zext i1 %1573 to i32
%1575 = add nuw nsw i32 %1570, %1574
%1576 = add nuw nsw i64 %1569, 1
%1577 = icmp eq i64 %1576, %162
br i1 %1577, label %1578, label %1568
1578: ; preds = %1568, %1190
%1579 = phi i32 [ %1194, %1190 ], [ %1575, %1568 ]
%1580 = icmp eq i32 %1579, 0
br i1 %1580, label %1581, label %2080
1581: ; preds = %1131, %1578
br i1 %41, label %1582, label %1655
1582: ; preds = %1581
%1583 = sext i32 %957 to i64
br i1 %297, label %1618, label %1584
1584: ; preds = %1582
%1585 = getelementptr double, double* %16, i64 %1583
%1586 = getelementptr double, double* %215, i64 %1583
%1587 = bitcast double* %1586 to i8*
%1588 = icmp ult i8* %28, %1587
%1589 = icmp ult double* %1585, %213
%1590 = and i1 %1588, %1589
%1591 = or i1 %1590, %300
br i1 %1591, label %1618, label %1592
1592: ; preds = %1584, %1592
%1593 = phi i64 [ %1615, %1592 ], [ 0, %1584 ]
%1594 = add nsw i64 %1593, %1583
%1595 = getelementptr inbounds double, double* %16, i64 %1594
%1596 = bitcast double* %1595 to <2 x double>*
%1597 = load <2 x double>, <2 x double>* %1596
%1598 = getelementptr inbounds double, double* %1595, i64 2
%1599 = bitcast double* %1598 to <2 x double>*
%1600 = load <2 x double>, <2 x double>* %1599
%1601 = getelementptr inbounds double, double* %21, i64 %1593
%1602 = bitcast double* %1601 to <2 x double>*
%1603 = load <2 x double>, <2 x double>* %1602
%1604 = getelementptr inbounds double, double* %1601, i64 2
%1605 = bitcast double* %1604 to <2 x double>*
%1606 = load <2 x double>, <2 x double>* %1605
%1607 = fmul <2 x double> %1603, <double 5.000000e-01, double 5.000000e-01>
%1608 = fmul <2 x double> %1606, <double 5.000000e-01, double 5.000000e-01>
%1609 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1597, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1607)
%1610 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1600, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1608)
%1611 = getelementptr inbounds double, double* %27, i64 %1593
%1612 = bitcast double* %1611 to <2 x double>*
store <2 x double> %1609, <2 x double>* %1612
%1613 = getelementptr inbounds double, double* %1611, i64 2
%1614 = bitcast double* %1613 to <2 x double>*
store <2 x double> %1610, <2 x double>* %1614
%1615 = add nuw i64 %1593, 4
%1616 = icmp eq i64 %1615, %301
br i1 %1616, label %1617, label %1592
1617: ; preds = %1592
br i1 %302, label %1655, label %1618
1618: ; preds = %1584, %1582, %1617
%1619 = phi i64 [ 0, %1584 ], [ 0, %1582 ], [ %301, %1617 ]
%1620 = xor i64 %1619, -1
br i1 %304, label %1631, label %1621
1621: ; preds = %1618
%1622 = add nsw i64 %1619, %1583
%1623 = getelementptr inbounds double, double* %16, i64 %1622
%1624 = load double, double* %1623
%1625 = getelementptr inbounds double, double* %21, i64 %1619
%1626 = load double, double* %1625
%1627 = fmul double %1626, 5.000000e-01
%1628 = tail call double @llvm.fmuladd.f64(double %1624, double 5.000000e-01, double %1627)
%1629 = getelementptr inbounds double, double* %27, i64 %1619
store double %1628, double* %1629
%1630 = or i64 %1619, 1
br label %1631
1631: ; preds = %1621, %1618
%1632 = phi i64 [ %1619, %1618 ], [ %1630, %1621 ]
%1633 = icmp eq i64 %1620, %305
br i1 %1633, label %1655, label %1634
1634: ; preds = %1631, %1634
%1635 = phi i64 [ %1653, %1634 ], [ %1632, %1631 ]
%1636 = add nsw i64 %1635, %1583
%1637 = getelementptr inbounds double, double* %16, i64 %1636
%1638 = load double, double* %1637
%1639 = getelementptr inbounds double, double* %21, i64 %1635
%1640 = load double, double* %1639
%1641 = fmul double %1640, 5.000000e-01
%1642 = tail call double @llvm.fmuladd.f64(double %1638, double 5.000000e-01, double %1641)
%1643 = getelementptr inbounds double, double* %27, i64 %1635
store double %1642, double* %1643
%1644 = add nuw nsw i64 %1635, 1
%1645 = add nsw i64 %1644, %1583
%1646 = getelementptr inbounds double, double* %16, i64 %1645
%1647 = load double, double* %1646
%1648 = getelementptr inbounds double, double* %21, i64 %1644
%1649 = load double, double* %1648
%1650 = fmul double %1649, 5.000000e-01
%1651 = tail call double @llvm.fmuladd.f64(double %1647, double 5.000000e-01, double %1650)
%1652 = getelementptr inbounds double, double* %27, i64 %1644
store double %1651, double* %1652
%1653 = add nuw nsw i64 %1635, 2
%1654 = icmp eq i64 %1653, %163
br i1 %1654, label %1655, label %1634
1655: ; preds = %1631, %1634, %1617, %1581
%1656 = tail call double %0(double* %27, i32 %2)
%1657 = sext i32 %956 to i64
%1658 = getelementptr inbounds double, double* %19, i64 %1657
%1659 = load double, double* %1658
%1660 = fcmp ugt double %1656, %1659
br i1 %1660, label %1762, label %1661
1661: ; preds = %1655
br i1 %41, label %1662, label %1786
1662: ; preds = %1661
%1663 = sext i32 %957 to i64
br i1 %306, label %1745, label %1664
1664: ; preds = %1662
%1665 = getelementptr double, double* %16, i64 %1663
%1666 = getelementptr double, double* %211, i64 %1663
%1667 = bitcast double* %1666 to i8*
%1668 = icmp ult double* %1665, %212
%1669 = icmp ult i8* %28, %1667
%1670 = and i1 %1668, %1669
br i1 %1670, label %1745, label %1671
1671: ; preds = %1664
br i1 %309, label %1725, label %1672
1672: ; preds = %1671, %1672
%1673 = phi i64 [ %1722, %1672 ], [ 0, %1671 ]
%1674 = phi i64 [ %1723, %1672 ], [ 0, %1671 ]
%1675 = getelementptr inbounds double, double* %27, i64 %1673
%1676 = bitcast double* %1675 to <2 x double>*
%1677 = load <2 x double>, <2 x double>* %1676
%1678 = getelementptr inbounds double, double* %1675, i64 2
%1679 = bitcast double* %1678 to <2 x double>*
%1680 = load <2 x double>, <2 x double>* %1679
%1681 = add nsw i64 %1673, %1663
%1682 = getelementptr inbounds double, double* %16, i64 %1681
%1683 = bitcast double* %1682 to <2 x double>*
store <2 x double> %1677, <2 x double>* %1683
%1684 = getelementptr inbounds double, double* %1682, i64 2
%1685 = bitcast double* %1684 to <2 x double>*
store <2 x double> %1680, <2 x double>* %1685
%1686 = or i64 %1673, 4
%1687 = getelementptr inbounds double, double* %27, i64 %1686
%1688 = bitcast double* %1687 to <2 x double>*
%1689 = load <2 x double>, <2 x double>* %1688
%1690 = getelementptr inbounds double, double* %1687, i64 2
%1691 = bitcast double* %1690 to <2 x double>*
%1692 = load <2 x double>, <2 x double>* %1691
%1693 = add nsw i64 %1686, %1663
%1694 = getelementptr inbounds double, double* %16, i64 %1693
%1695 = bitcast double* %1694 to <2 x double>*
store <2 x double> %1689, <2 x double>* %1695
%1696 = getelementptr inbounds double, double* %1694, i64 2
%1697 = bitcast double* %1696 to <2 x double>*
store <2 x double> %1692, <2 x double>* %1697
%1698 = or i64 %1673, 8
%1699 = getelementptr inbounds double, double* %27, i64 %1698
%1700 = bitcast double* %1699 to <2 x double>*
%1701 = load <2 x double>, <2 x double>* %1700
%1702 = getelementptr inbounds double, double* %1699, i64 2
%1703 = bitcast double* %1702 to <2 x double>*
%1704 = load <2 x double>, <2 x double>* %1703
%1705 = add nsw i64 %1698, %1663
%1706 = getelementptr inbounds double, double* %16, i64 %1705
%1707 = bitcast double* %1706 to <2 x double>*
store <2 x double> %1701, <2 x double>* %1707
%1708 = getelementptr inbounds double, double* %1706, i64 2
%1709 = bitcast double* %1708 to <2 x double>*
store <2 x double> %1704, <2 x double>* %1709
%1710 = or i64 %1673, 12
%1711 = getelementptr inbounds double, double* %27, i64 %1710
%1712 = bitcast double* %1711 to <2 x double>*
%1713 = load <2 x double>, <2 x double>* %1712
%1714 = getelementptr inbounds double, double* %1711, i64 2
%1715 = bitcast double* %1714 to <2 x double>*
%1716 = load <2 x double>, <2 x double>* %1715
%1717 = add nsw i64 %1710, %1663
%1718 = getelementptr inbounds double, double* %16, i64 %1717
%1719 = bitcast double* %1718 to <2 x double>*
store <2 x double> %1713, <2 x double>* %1719
%1720 = getelementptr inbounds double, double* %1718, i64 2
%1721 = bitcast double* %1720 to <2 x double>*
store <2 x double> %1716, <2 x double>* %1721
%1722 = add nuw i64 %1673, 16
%1723 = add nuw i64 %1674, 4
%1724 = icmp eq i64 %1723, %310
br i1 %1724, label %1725, label %1672
1725: ; preds = %1672, %1671
%1726 = phi i64 [ 0, %1671 ], [ %1722, %1672 ]
br i1 %311, label %1744, label %1727
1727: ; preds = %1725, %1727
%1728 = phi i64 [ %1741, %1727 ], [ %1726, %1725 ]
%1729 = phi i64 [ %1742, %1727 ], [ 0, %1725 ]
%1730 = getelementptr inbounds double, double* %27, i64 %1728
%1731 = bitcast double* %1730 to <2 x double>*
%1732 = load <2 x double>, <2 x double>* %1731
%1733 = getelementptr inbounds double, double* %1730, i64 2
%1734 = bitcast double* %1733 to <2 x double>*
%1735 = load <2 x double>, <2 x double>* %1734
%1736 = add nsw i64 %1728, %1663
%1737 = getelementptr inbounds double, double* %16, i64 %1736
%1738 = bitcast double* %1737 to <2 x double>*
store <2 x double> %1732, <2 x double>* %1738
%1739 = getelementptr inbounds double, double* %1737, i64 2
%1740 = bitcast double* %1739 to <2 x double>*
store <2 x double> %1735, <2 x double>* %1740
%1741 = add nuw i64 %1728, 4
%1742 = add i64 %1729, 1
%1743 = icmp eq i64 %1742, %308
br i1 %1743, label %1744, label %1727
1744: ; preds = %1727, %1725
br i1 %312, label %1786, label %1745
1745: ; preds = %1664, %1662, %1744
%1746 = phi i64 [ 0, %1664 ], [ 0, %1662 ], [ %307, %1744 ]
%1747 = xor i64 %1746, -1
%1748 = add nsw i64 %1747, %156
br i1 %314, label %1759, label %1749
1749: ; preds = %1745, %1749
%1750 = phi i64 [ %1756, %1749 ], [ %1746, %1745 ]
%1751 = phi i64 [ %1757, %1749 ], [ 0, %1745 ]
%1752 = getelementptr inbounds double, double* %27, i64 %1750
%1753 = load double, double* %1752
%1754 = add nsw i64 %1750, %1663
%1755 = getelementptr inbounds double, double* %16, i64 %1754
store double %1753, double* %1755
%1756 = add nuw nsw i64 %1750, 1
%1757 = add i64 %1751, 1
%1758 = icmp eq i64 %1757, %313
br i1 %1758, label %1759, label %1749
1759: ; preds = %1749, %1745
%1760 = phi i64 [ %1746, %1745 ], [ %1756, %1749 ]
%1761 = icmp ult i64 %1748, 3
br i1 %1761, label %1786, label %1763
1762: ; preds = %1655
br i1 %152, label %1895, label %1787
1763: ; preds = %1759, %1763
%1764 = phi i64 [ %1784, %1763 ], [ %1760, %1759 ]
%1765 = getelementptr inbounds double, double* %27, i64 %1764
%1766 = load double, double* %1765
%1767 = add nsw i64 %1764, %1663
%1768 = getelementptr inbounds double, double* %16, i64 %1767
store double %1766, double* %1768
%1769 = add nuw nsw i64 %1764, 1
%1770 = getelementptr inbounds double, double* %27, i64 %1769
%1771 = load double, double* %1770
%1772 = add nsw i64 %1769, %1663
%1773 = getelementptr inbounds double, double* %16, i64 %1772
store double %1771, double* %1773
%1774 = add nuw nsw i64 %1764, 2
%1775 = getelementptr inbounds double, double* %27, i64 %1774
%1776 = load double, double* %1775
%1777 = add nsw i64 %1774, %1663
%1778 = getelementptr inbounds double, double* %16, i64 %1777
store double %1776, double* %1778
%1779 = add nuw nsw i64 %1764, 3
%1780 = getelementptr inbounds double, double* %27, i64 %1779
%1781 = load double, double* %1780
%1782 = add nsw i64 %1779, %1663
%1783 = getelementptr inbounds double, double* %16, i64 %1782
store double %1781, double* %1783
%1784 = add nuw nsw i64 %1764, 4
%1785 = icmp eq i64 %1784, %164
br i1 %1785, label %1786, label %1763
1786: ; preds = %1759, %1763, %1744, %1661
store double %1656, double* %1658
br label %2080
1787: ; preds = %1762, %1890
%1788 = phi i64 [ %1893, %1890 ], [ 0, %1762 ]
%1789 = mul i64 %1788, %12
%1790 = getelementptr double, double* %16, i64 %1789
%1791 = add i64 %1789, %156
%1792 = getelementptr double, double* %16, i64 %1791
%1793 = bitcast double* %1792 to i8*
%1794 = mul nsw i64 %1788, %12
br i1 %41, label %1795, label %1890
1795: ; preds = %1787
br i1 %315, label %1853, label %1796
1796: ; preds = %1795
%1797 = icmp ult double* %1790, %207
%1798 = icmp ult i8* %31, %1793
%1799 = and i1 %1797, %1798
%1800 = icmp ult double* %1790, %209
%1801 = icmp ult i8* %34, %1793
%1802 = and i1 %1800, %1801
%1803 = or i1 %1799, %1802
%1804 = or i1 %1803, %318
br i1 %1804, label %1853, label %1805
1805: ; preds = %1796
br i1 %321, label %1837, label %1806
1806: ; preds = %1805, %1806
%1807 = phi i64 [ %1834, %1806 ], [ 0, %1805 ]
%1808 = phi i64 [ %1835, %1806 ], [ 0, %1805 ]
%1809 = add nsw i64 %1807, %1794
%1810 = getelementptr inbounds double, double* %16, i64 %1809
%1811 = bitcast double* %1810 to <2 x double>*
%1812 = load <2 x double>, <2 x double>* %1811
%1813 = getelementptr inbounds double, double* %33, i64 %1807
%1814 = bitcast double* %1813 to <2 x double>*
%1815 = load <2 x double>, <2 x double>* %1814
%1816 = fadd <2 x double> %1812, %1815
%1817 = fmul <2 x double> %1816, <double 5.000000e-01, double 5.000000e-01>
%1818 = bitcast double* %1810 to <2 x double>*
store <2 x double> %1817, <2 x double>* %1818
%1819 = getelementptr inbounds double, double* %30, i64 %1807
%1820 = bitcast double* %1819 to <2 x double>*
store <2 x double> %1817, <2 x double>* %1820
%1821 = or i64 %1807, 2
%1822 = add nsw i64 %1821, %1794
%1823 = getelementptr inbounds double, double* %16, i64 %1822
%1824 = bitcast double* %1823 to <2 x double>*
%1825 = load <2 x double>, <2 x double>* %1824
%1826 = getelementptr inbounds double, double* %33, i64 %1821
%1827 = bitcast double* %1826 to <2 x double>*
%1828 = load <2 x double>, <2 x double>* %1827
%1829 = fadd <2 x double> %1825, %1828
%1830 = fmul <2 x double> %1829, <double 5.000000e-01, double 5.000000e-01>
%1831 = bitcast double* %1823 to <2 x double>*
store <2 x double> %1830, <2 x double>* %1831
%1832 = getelementptr inbounds double, double* %30, i64 %1821
%1833 = bitcast double* %1832 to <2 x double>*
store <2 x double> %1830, <2 x double>* %1833
%1834 = add nuw i64 %1807, 4
%1835 = add nuw i64 %1808, 2
%1836 = icmp eq i64 %1835, %322
br i1 %1836, label %1837, label %1806
1837: ; preds = %1806, %1805
%1838 = phi i64 [ 0, %1805 ], [ %1834, %1806 ]
br i1 %323, label %1852, label %1839
1839: ; preds = %1837
%1840 = add nsw i64 %1838, %1794
%1841 = getelementptr inbounds double, double* %16, i64 %1840
%1842 = bitcast double* %1841 to <2 x double>*
%1843 = load <2 x double>, <2 x double>* %1842
%1844 = getelementptr inbounds double, double* %33, i64 %1838
%1845 = bitcast double* %1844 to <2 x double>*
%1846 = load <2 x double>, <2 x double>* %1845
%1847 = fadd <2 x double> %1843, %1846
%1848 = fmul <2 x double> %1847, <double 5.000000e-01, double 5.000000e-01>
%1849 = bitcast double* %1841 to <2 x double>*
store <2 x double> %1848, <2 x double>* %1849
%1850 = getelementptr inbounds double, double* %30, i64 %1838
%1851 = bitcast double* %1850 to <2 x double>*
store <2 x double> %1848, <2 x double>* %1851
br label %1852
1852: ; preds = %1837, %1839
br i1 %324, label %1890, label %1853
1853: ; preds = %1796, %1795, %1852
%1854 = phi i64 [ 0, %1796 ], [ 0, %1795 ], [ %319, %1852 ]
%1855 = xor i64 %1854, -1
br i1 %326, label %1866, label %1856
1856: ; preds = %1853
%1857 = add nsw i64 %1854, %1794
%1858 = getelementptr inbounds double, double* %16, i64 %1857
%1859 = load double, double* %1858
%1860 = getelementptr inbounds double, double* %33, i64 %1854
%1861 = load double, double* %1860
%1862 = fadd double %1859, %1861
%1863 = fmul double %1862, 5.000000e-01
store double %1863, double* %1858
%1864 = getelementptr inbounds double, double* %30, i64 %1854
store double %1863, double* %1864
%1865 = or i64 %1854, 1
br label %1866
1866: ; preds = %1856, %1853
%1867 = phi i64 [ %1854, %1853 ], [ %1865, %1856 ]
%1868 = icmp eq i64 %1855, %327
br i1 %1868, label %1890, label %1869
1869: ; preds = %1866, %1869
%1870 = phi i64 [ %1888, %1869 ], [ %1867, %1866 ]
%1871 = add nsw i64 %1870, %1794
%1872 = getelementptr inbounds double, double* %16, i64 %1871
%1873 = load double, double* %1872
%1874 = getelementptr inbounds double, double* %33, i64 %1870
%1875 = load double, double* %1874
%1876 = fadd double %1873, %1875
%1877 = fmul double %1876, 5.000000e-01
store double %1877, double* %1872
%1878 = getelementptr inbounds double, double* %30, i64 %1870
store double %1877, double* %1878
%1879 = add nuw nsw i64 %1870, 1
%1880 = add nsw i64 %1879, %1794
%1881 = getelementptr inbounds double, double* %16, i64 %1880
%1882 = load double, double* %1881
%1883 = getelementptr inbounds double, double* %33, i64 %1879
%1884 = load double, double* %1883
%1885 = fadd double %1882, %1884
%1886 = fmul double %1885, 5.000000e-01
store double %1886, double* %1881
%1887 = getelementptr inbounds double, double* %30, i64 %1879
store double %1886, double* %1887
%1888 = add nuw nsw i64 %1870, 2
%1889 = icmp eq i64 %1888, %166
br i1 %1889, label %1890, label %1869
1890: ; preds = %1866, %1869, %1852, %1787
%1891 = tail call double %0(double* %30, i32 %2)
%1892 = getelementptr inbounds double, double* %19, i64 %1788
store double %1891, double* %1892
%1893 = add nuw nsw i64 %1788, 1
%1894 = icmp eq i64 %1893, %165
br i1 %1894, label %1895, label %1787
1895: ; preds = %1890, %1762
%1896 = load double, double* %19
br i1 %151, label %1953, label %1897
1897: ; preds = %1895
br i1 %329, label %1933, label %1898
1898: ; preds = %1897, %1898
%1899 = phi i64 [ %1930, %1898 ], [ 1, %1897 ]
%1900 = phi i32 [ %1929, %1898 ], [ 0, %1897 ]
%1901 = phi double [ %1927, %1898 ], [ %1896, %1897 ]
%1902 = phi i64 [ %1931, %1898 ], [ 0, %1897 ]
%1903 = getelementptr inbounds double, double* %19, i64 %1899
%1904 = load double, double* %1903
%1905 = fcmp olt double %1904, %1901
%1906 = select i1 %1905, double %1904, double %1901
%1907 = trunc i64 %1899 to i32
%1908 = select i1 %1905, i32 %1907, i32 %1900
%1909 = add nuw nsw i64 %1899, 1
%1910 = getelementptr inbounds double, double* %19, i64 %1909
%1911 = load double, double* %1910
%1912 = fcmp olt double %1911, %1906
%1913 = select i1 %1912, double %1911, double %1906
%1914 = trunc i64 %1909 to i32
%1915 = select i1 %1912, i32 %1914, i32 %1908
%1916 = add nuw nsw i64 %1899, 2
%1917 = getelementptr inbounds double, double* %19, i64 %1916
%1918 = load double, double* %1917
%1919 = fcmp olt double %1918, %1913
%1920 = select i1 %1919, double %1918, double %1913
%1921 = trunc i64 %1916 to i32
%1922 = select i1 %1919, i32 %1921, i32 %1915
%1923 = add nuw nsw i64 %1899, 3
%1924 = getelementptr inbounds double, double* %19, i64 %1923
%1925 = load double, double* %1924
%1926 = fcmp olt double %1925, %1920
%1927 = select i1 %1926, double %1925, double %1920
%1928 = trunc i64 %1923 to i32
%1929 = select i1 %1926, i32 %1928, i32 %1922
%1930 = add nuw nsw i64 %1899, 4
%1931 = add i64 %1902, 4
%1932 = icmp eq i64 %1931, %330
br i1 %1932, label %1933, label %1898
1933: ; preds = %1898, %1897
%1934 = phi double [ undef, %1897 ], [ %1927, %1898 ]
%1935 = phi i32 [ undef, %1897 ], [ %1929, %1898 ]
%1936 = phi i64 [ 1, %1897 ], [ %1930, %1898 ]
%1937 = phi i32 [ 0, %1897 ], [ %1929, %1898 ]
%1938 = phi double [ %1896, %1897 ], [ %1927, %1898 ]
br i1 %331, label %1953, label %1939
1939: ; preds = %1933, %1939
%1940 = phi i64 [ %1950, %1939 ], [ %1936, %1933 ]
%1941 = phi i32 [ %1949, %1939 ], [ %1937, %1933 ]
%1942 = phi double [ %1947, %1939 ], [ %1938, %1933 ]
%1943 = phi i64 [ %1951, %1939 ], [ 0, %1933 ]
%1944 = getelementptr inbounds double, double* %19, i64 %1940
%1945 = load double, double* %1944
%1946 = fcmp olt double %1945, %1942
%1947 = select i1 %1946, double %1945, double %1942
%1948 = trunc i64 %1940 to i32
%1949 = select i1 %1946, i32 %1948, i32 %1941
%1950 = add nuw nsw i64 %1940, 1
%1951 = add i64 %1943, 1
%1952 = icmp eq i64 %1951, %328
br i1 %1952, label %1953, label %1939
1953: ; preds = %1933, %1939, %1895
%1954 = phi double [ %1896, %1895 ], [ %1934, %1933 ], [ %1947, %1939 ]
%1955 = phi i32 [ 0, %1895 ], [ %1935, %1933 ], [ %1949, %1939 ]
%1956 = mul i32 %1955, %2
br i1 %41, label %1957, label %2418
1957: ; preds = %1953
%1958 = sext i32 %1956 to i64
br i1 %332, label %2040, label %1959
1959: ; preds = %1957
%1960 = getelementptr double, double* %16, i64 %1958
%1961 = getelementptr double, double* %206, i64 %1958
%1962 = bitcast double* %1961 to i8*
%1963 = icmp ult i8* %34, %1962
%1964 = icmp ult double* %1960, %205
%1965 = and i1 %1963, %1964
br i1 %1965, label %2040, label %1966
1966: ; preds = %1959
br i1 %335, label %2020, label %1967
1967: ; preds = %1966, %1967
%1968 = phi i64 [ %2017, %1967 ], [ 0, %1966 ]
%1969 = phi i64 [ %2018, %1967 ], [ 0, %1966 ]
%1970 = add nsw i64 %1968, %1958
%1971 = getelementptr inbounds double, double* %16, i64 %1970
%1972 = bitcast double* %1971 to <2 x double>*
%1973 = load <2 x double>, <2 x double>* %1972
%1974 = getelementptr inbounds double, double* %1971, i64 2
%1975 = bitcast double* %1974 to <2 x double>*
%1976 = load <2 x double>, <2 x double>* %1975
%1977 = getelementptr inbounds double, double* %33, i64 %1968
%1978 = bitcast double* %1977 to <2 x double>*
store <2 x double> %1973, <2 x double>* %1978
%1979 = getelementptr inbounds double, double* %1977, i64 2
%1980 = bitcast double* %1979 to <2 x double>*
store <2 x double> %1976, <2 x double>* %1980
%1981 = or i64 %1968, 4
%1982 = add nsw i64 %1981, %1958
%1983 = getelementptr inbounds double, double* %16, i64 %1982
%1984 = bitcast double* %1983 to <2 x double>*
%1985 = load <2 x double>, <2 x double>* %1984
%1986 = getelementptr inbounds double, double* %1983, i64 2
%1987 = bitcast double* %1986 to <2 x double>*
%1988 = load <2 x double>, <2 x double>* %1987
%1989 = getelementptr inbounds double, double* %33, i64 %1981
%1990 = bitcast double* %1989 to <2 x double>*
store <2 x double> %1985, <2 x double>* %1990
%1991 = getelementptr inbounds double, double* %1989, i64 2
%1992 = bitcast double* %1991 to <2 x double>*
store <2 x double> %1988, <2 x double>* %1992
%1993 = or i64 %1968, 8
%1994 = add nsw i64 %1993, %1958
%1995 = getelementptr inbounds double, double* %16, i64 %1994
%1996 = bitcast double* %1995 to <2 x double>*
%1997 = load <2 x double>, <2 x double>* %1996
%1998 = getelementptr inbounds double, double* %1995, i64 2
%1999 = bitcast double* %1998 to <2 x double>*
%2000 = load <2 x double>, <2 x double>* %1999
%2001 = getelementptr inbounds double, double* %33, i64 %1993
%2002 = bitcast double* %2001 to <2 x double>*
store <2 x double> %1997, <2 x double>* %2002
%2003 = getelementptr inbounds double, double* %2001, i64 2
%2004 = bitcast double* %2003 to <2 x double>*
store <2 x double> %2000, <2 x double>* %2004
%2005 = or i64 %1968, 12
%2006 = add nsw i64 %2005, %1958
%2007 = getelementptr inbounds double, double* %16, i64 %2006
%2008 = bitcast double* %2007 to <2 x double>*
%2009 = load <2 x double>, <2 x double>* %2008
%2010 = getelementptr inbounds double, double* %2007, i64 2
%2011 = bitcast double* %2010 to <2 x double>*
%2012 = load <2 x double>, <2 x double>* %2011
%2013 = getelementptr inbounds double, double* %33, i64 %2005
%2014 = bitcast double* %2013 to <2 x double>*
store <2 x double> %2009, <2 x double>* %2014
%2015 = getelementptr inbounds double, double* %2013, i64 2
%2016 = bitcast double* %2015 to <2 x double>*
store <2 x double> %2012, <2 x double>* %2016
%2017 = add nuw i64 %1968, 16
%2018 = add nuw i64 %1969, 4
%2019 = icmp eq i64 %2018, %336
br i1 %2019, label %2020, label %1967
2020: ; preds = %1967, %1966
%2021 = phi i64 [ 0, %1966 ], [ %2017, %1967 ]
br i1 %337, label %2039, label %2022
2022: ; preds = %2020, %2022
%2023 = phi i64 [ %2036, %2022 ], [ %2021, %2020 ]
%2024 = phi i64 [ %2037, %2022 ], [ 0, %2020 ]
%2025 = add nsw i64 %2023, %1958
%2026 = getelementptr inbounds double, double* %16, i64 %2025
%2027 = bitcast double* %2026 to <2 x double>*
%2028 = load <2 x double>, <2 x double>* %2027
%2029 = getelementptr inbounds double, double* %2026, i64 2
%2030 = bitcast double* %2029 to <2 x double>*
%2031 = load <2 x double>, <2 x double>* %2030
%2032 = getelementptr inbounds double, double* %33, i64 %2023
%2033 = bitcast double* %2032 to <2 x double>*
store <2 x double> %2028, <2 x double>* %2033
%2034 = getelementptr inbounds double, double* %2032, i64 2
%2035 = bitcast double* %2034 to <2 x double>*
store <2 x double> %2031, <2 x double>* %2035
%2036 = add nuw i64 %2023, 4
%2037 = add i64 %2024, 1
%2038 = icmp eq i64 %2037, %334
br i1 %2038, label %2039, label %2022
2039: ; preds = %2022, %2020
br i1 %338, label %2080, label %2040
2040: ; preds = %1959, %1957, %2039
%2041 = phi i64 [ 0, %1959 ], [ 0, %1957 ], [ %333, %2039 ]
%2042 = xor i64 %2041, -1
%2043 = add nsw i64 %2042, %156
br i1 %340, label %2054, label %2044
2044: ; preds = %2040, %2044
%2045 = phi i64 [ %2051, %2044 ], [ %2041, %2040 ]
%2046 = phi i64 [ %2052, %2044 ], [ 0, %2040 ]
%2047 = add nsw i64 %2045, %1958
%2048 = getelementptr inbounds double, double* %16, i64 %2047
%2049 = load double, double* %2048
%2050 = getelementptr inbounds double, double* %33, i64 %2045
store double %2049, double* %2050
%2051 = add nuw nsw i64 %2045, 1
%2052 = add i64 %2046, 1
%2053 = icmp eq i64 %2052, %339
br i1 %2053, label %2054, label %2044
2054: ; preds = %2044, %2040
%2055 = phi i64 [ %2041, %2040 ], [ %2051, %2044 ]
%2056 = icmp ult i64 %2043, 3
br i1 %2056, label %2080, label %2057
2057: ; preds = %2054, %2057
%2058 = phi i64 [ %2078, %2057 ], [ %2055, %2054 ]
%2059 = add nsw i64 %2058, %1958
%2060 = getelementptr inbounds double, double* %16, i64 %2059
%2061 = load double, double* %2060
%2062 = getelementptr inbounds double, double* %33, i64 %2058
store double %2061, double* %2062
%2063 = add nuw nsw i64 %2058, 1
%2064 = add nsw i64 %2063, %1958
%2065 = getelementptr inbounds double, double* %16, i64 %2064
%2066 = load double, double* %2065
%2067 = getelementptr inbounds double, double* %33, i64 %2063
store double %2066, double* %2067
%2068 = add nuw nsw i64 %2058, 2
%2069 = add nsw i64 %2068, %1958
%2070 = getelementptr inbounds double, double* %16, i64 %2069
%2071 = load double, double* %2070
%2072 = getelementptr inbounds double, double* %33, i64 %2068
store double %2071, double* %2072
%2073 = add nuw nsw i64 %2058, 3
%2074 = add nsw i64 %2073, %1958
%2075 = getelementptr inbounds double, double* %16, i64 %2074
%2076 = load double, double* %2075
%2077 = getelementptr inbounds double, double* %33, i64 %2073
store double %2076, double* %2077
%2078 = add nuw nsw i64 %2058, 4
%2079 = icmp eq i64 %2078, %167
br i1 %2079, label %2080, label %2057
2080: ; preds = %2054, %2057, %2039, %1786, %1578
%2081 = phi i32 [ 0, %1786 ], [ %1579, %1578 ], [ 0, %2039 ], [ 0, %2057 ], [ 0, %2054 ]
%2082 = phi double [ %930, %1786 ], [ %930, %1578 ], [ %1954, %2039 ], [ %1954, %2057 ], [ %1954, %2054 ]
%2083 = phi i32 [ %931, %1786 ], [ %931, %1578 ], [ %1955, %2039 ], [ %1955, %2057 ], [ %1955, %2054 ]
%2084 = phi i32 [ %957, %1786 ], [ %957, %1578 ], [ %1956, %2039 ], [ %1956, %2057 ], [ %1956, %2054 ]
%2085 = icmp eq i32 %2081, 1
br i1 %2085, label %2086, label %2415
2086: ; preds = %2080
br i1 %41, label %2087, label %2160
2087: ; preds = %2086
%2088 = sext i32 %2084 to i64
br i1 %341, label %2123, label %2089
2089: ; preds = %2087
%2090 = getelementptr double, double* %16, i64 %2088
%2091 = getelementptr double, double* %202, i64 %2088
%2092 = bitcast double* %2091 to i8*
%2093 = icmp ult i8* %28, %2092
%2094 = icmp ult double* %2090, %200
%2095 = and i1 %2093, %2094
%2096 = or i1 %2095, %344
br i1 %2096, label %2123, label %2097
2097: ; preds = %2089, %2097
%2098 = phi i64 [ %2120, %2097 ], [ 0, %2089 ]
%2099 = add nsw i64 %2098, %2088
%2100 = getelementptr inbounds double, double* %16, i64 %2099
%2101 = bitcast double* %2100 to <2 x double>*
%2102 = load <2 x double>, <2 x double>* %2101
%2103 = getelementptr inbounds double, double* %2100, i64 2
%2104 = bitcast double* %2103 to <2 x double>*
%2105 = load <2 x double>, <2 x double>* %2104
%2106 = getelementptr inbounds double, double* %21, i64 %2098
%2107 = bitcast double* %2106 to <2 x double>*
%2108 = load <2 x double>, <2 x double>* %2107
%2109 = getelementptr inbounds double, double* %2106, i64 2
%2110 = bitcast double* %2109 to <2 x double>*
%2111 = load <2 x double>, <2 x double>* %2110
%2112 = fmul <2 x double> %2108, <double 5.000000e-01, double 5.000000e-01>
%2113 = fmul <2 x double> %2111, <double 5.000000e-01, double 5.000000e-01>
%2114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2102, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %2112)
%2115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2105, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %2113)
%2116 = getelementptr inbounds double, double* %27, i64 %2098
%2117 = bitcast double* %2116 to <2 x double>*
store <2 x double> %2114, <2 x double>* %2117
%2118 = getelementptr inbounds double, double* %2116, i64 2
%2119 = bitcast double* %2118 to <2 x double>*
store <2 x double> %2115, <2 x double>* %2119
%2120 = add nuw i64 %2098, 4
%2121 = icmp eq i64 %2120, %345
br i1 %2121, label %2122, label %2097
2122: ; preds = %2097
br i1 %346, label %2160, label %2123
2123: ; preds = %2089, %2087, %2122
%2124 = phi i64 [ 0, %2089 ], [ 0, %2087 ], [ %345, %2122 ]
%2125 = xor i64 %2124, -1
br i1 %348, label %2136, label %2126
2126: ; preds = %2123
%2127 = add nsw i64 %2124, %2088
%2128 = getelementptr inbounds double, double* %16, i64 %2127
%2129 = load double, double* %2128
%2130 = getelementptr inbounds double, double* %21, i64 %2124
%2131 = load double, double* %2130
%2132 = fmul double %2131, 5.000000e-01
%2133 = tail call double @llvm.fmuladd.f64(double %2129, double 5.000000e-01, double %2132)
%2134 = getelementptr inbounds double, double* %27, i64 %2124
store double %2133, double* %2134
%2135 = or i64 %2124, 1
br label %2136
2136: ; preds = %2126, %2123
%2137 = phi i64 [ %2124, %2123 ], [ %2135, %2126 ]
%2138 = icmp eq i64 %2125, %349
br i1 %2138, label %2160, label %2139
2139: ; preds = %2136, %2139
%2140 = phi i64 [ %2158, %2139 ], [ %2137, %2136 ]
%2141 = add nsw i64 %2140, %2088
%2142 = getelementptr inbounds double, double* %16, i64 %2141
%2143 = load double, double* %2142
%2144 = getelementptr inbounds double, double* %21, i64 %2140
%2145 = load double, double* %2144
%2146 = fmul double %2145, 5.000000e-01
%2147 = tail call double @llvm.fmuladd.f64(double %2143, double 5.000000e-01, double %2146)
%2148 = getelementptr inbounds double, double* %27, i64 %2140
store double %2147, double* %2148
%2149 = add nuw nsw i64 %2140, 1
%2150 = add nsw i64 %2149, %2088
%2151 = getelementptr inbounds double, double* %16, i64 %2150
%2152 = load double, double* %2151
%2153 = getelementptr inbounds double, double* %21, i64 %2149
%2154 = load double, double* %2153
%2155 = fmul double %2154, 5.000000e-01
%2156 = tail call double @llvm.fmuladd.f64(double %2152, double 5.000000e-01, double %2155)
%2157 = getelementptr inbounds double, double* %27, i64 %2149
store double %2156, double* %2157
%2158 = add nuw nsw i64 %2140, 2
%2159 = icmp eq i64 %2158, %168
br i1 %2159, label %2160, label %2139
2160: ; preds = %2136, %2139, %2122, %2086
%2161 = tail call double %0(double* %27, i32 %2)
%2162 = fcmp ugt double %2161, %1129
br i1 %2162, label %2264, label %2163
2163: ; preds = %2160
br i1 %41, label %2164, label %2411
2164: ; preds = %2163
%2165 = sext i32 %957 to i64
br i1 %350, label %2247, label %2166
2166: ; preds = %2164
%2167 = getelementptr double, double* %16, i64 %2165
%2168 = getelementptr double, double* %198, i64 %2165
%2169 = bitcast double* %2168 to i8*
%2170 = icmp ult double* %2167, %199
%2171 = icmp ult i8* %28, %2169
%2172 = and i1 %2170, %2171
br i1 %2172, label %2247, label %2173
2173: ; preds = %2166
br i1 %353, label %2227, label %2174
2174: ; preds = %2173, %2174
%2175 = phi i64 [ %2224, %2174 ], [ 0, %2173 ]
%2176 = phi i64 [ %2225, %2174 ], [ 0, %2173 ]
%2177 = getelementptr inbounds double, double* %27, i64 %2175
%2178 = bitcast double* %2177 to <2 x double>*
%2179 = load <2 x double>, <2 x double>* %2178
%2180 = getelementptr inbounds double, double* %2177, i64 2
%2181 = bitcast double* %2180 to <2 x double>*
%2182 = load <2 x double>, <2 x double>* %2181
%2183 = add nsw i64 %2175, %2165
%2184 = getelementptr inbounds double, double* %16, i64 %2183
%2185 = bitcast double* %2184 to <2 x double>*
store <2 x double> %2179, <2 x double>* %2185
%2186 = getelementptr inbounds double, double* %2184, i64 2
%2187 = bitcast double* %2186 to <2 x double>*
store <2 x double> %2182, <2 x double>* %2187
%2188 = or i64 %2175, 4
%2189 = getelementptr inbounds double, double* %27, i64 %2188
%2190 = bitcast double* %2189 to <2 x double>*
%2191 = load <2 x double>, <2 x double>* %2190
%2192 = getelementptr inbounds double, double* %2189, i64 2
%2193 = bitcast double* %2192 to <2 x double>*
%2194 = load <2 x double>, <2 x double>* %2193
%2195 = add nsw i64 %2188, %2165
%2196 = getelementptr inbounds double, double* %16, i64 %2195
%2197 = bitcast double* %2196 to <2 x double>*
store <2 x double> %2191, <2 x double>* %2197
%2198 = getelementptr inbounds double, double* %2196, i64 2
%2199 = bitcast double* %2198 to <2 x double>*
store <2 x double> %2194, <2 x double>* %2199
%2200 = or i64 %2175, 8
%2201 = getelementptr inbounds double, double* %27, i64 %2200
%2202 = bitcast double* %2201 to <2 x double>*
%2203 = load <2 x double>, <2 x double>* %2202
%2204 = getelementptr inbounds double, double* %2201, i64 2
%2205 = bitcast double* %2204 to <2 x double>*
%2206 = load <2 x double>, <2 x double>* %2205
%2207 = add nsw i64 %2200, %2165
%2208 = getelementptr inbounds double, double* %16, i64 %2207
%2209 = bitcast double* %2208 to <2 x double>*
store <2 x double> %2203, <2 x double>* %2209
%2210 = getelementptr inbounds double, double* %2208, i64 2
%2211 = bitcast double* %2210 to <2 x double>*
store <2 x double> %2206, <2 x double>* %2211
%2212 = or i64 %2175, 12
%2213 = getelementptr inbounds double, double* %27, i64 %2212
%2214 = bitcast double* %2213 to <2 x double>*
%2215 = load <2 x double>, <2 x double>* %2214
%2216 = getelementptr inbounds double, double* %2213, i64 2
%2217 = bitcast double* %2216 to <2 x double>*
%2218 = load <2 x double>, <2 x double>* %2217
%2219 = add nsw i64 %2212, %2165
%2220 = getelementptr inbounds double, double* %16, i64 %2219
%2221 = bitcast double* %2220 to <2 x double>*
store <2 x double> %2215, <2 x double>* %2221
%2222 = getelementptr inbounds double, double* %2220, i64 2
%2223 = bitcast double* %2222 to <2 x double>*
store <2 x double> %2218, <2 x double>* %2223
%2224 = add nuw i64 %2175, 16
%2225 = add nuw i64 %2176, 4
%2226 = icmp eq i64 %2225, %354
br i1 %2226, label %2227, label %2174
2227: ; preds = %2174, %2173
%2228 = phi i64 [ 0, %2173 ], [ %2224, %2174 ]
br i1 %355, label %2246, label %2229
2229: ; preds = %2227, %2229
%2230 = phi i64 [ %2243, %2229 ], [ %2228, %2227 ]
%2231 = phi i64 [ %2244, %2229 ], [ 0, %2227 ]
%2232 = getelementptr inbounds double, double* %27, i64 %2230
%2233 = bitcast double* %2232 to <2 x double>*
%2234 = load <2 x double>, <2 x double>* %2233
%2235 = getelementptr inbounds double, double* %2232, i64 2
%2236 = bitcast double* %2235 to <2 x double>*
%2237 = load <2 x double>, <2 x double>* %2236
%2238 = add nsw i64 %2230, %2165
%2239 = getelementptr inbounds double, double* %16, i64 %2238
%2240 = bitcast double* %2239 to <2 x double>*
store <2 x double> %2234, <2 x double>* %2240
%2241 = getelementptr inbounds double, double* %2239, i64 2
%2242 = bitcast double* %2241 to <2 x double>*
store <2 x double> %2237, <2 x double>* %2242
%2243 = add nuw i64 %2230, 4
%2244 = add i64 %2231, 1
%2245 = icmp eq i64 %2244, %352
br i1 %2245, label %2246, label %2229
2246: ; preds = %2229, %2227
br i1 %356, label %2411, label %2247
2247: ; preds = %2166, %2164, %2246
%2248 = phi i64 [ 0, %2166 ], [ 0, %2164 ], [ %351, %2246 ]
%2249 = xor i64 %2248, -1
%2250 = add nsw i64 %2249, %156
br i1 %358, label %2261, label %2251
2251: ; preds = %2247, %2251
%2252 = phi i64 [ %2258, %2251 ], [ %2248, %2247 ]
%2253 = phi i64 [ %2259, %2251 ], [ 0, %2247 ]
%2254 = getelementptr inbounds double, double* %27, i64 %2252
%2255 = load double, double* %2254
%2256 = add nsw i64 %2252, %2165
%2257 = getelementptr inbounds double, double* %16, i64 %2256
store double %2255, double* %2257
%2258 = add nuw nsw i64 %2252, 1
%2259 = add i64 %2253, 1
%2260 = icmp eq i64 %2259, %357
br i1 %2260, label %2261, label %2251
2261: ; preds = %2251, %2247
%2262 = phi i64 [ %2248, %2247 ], [ %2258, %2251 ]
%2263 = icmp ult i64 %2250, 3
br i1 %2263, label %2411, label %2365
2264: ; preds = %2160
br i1 %41, label %2265, label %2411
2265: ; preds = %2264
%2266 = sext i32 %957 to i64
br i1 %359, label %2348, label %2267
2267: ; preds = %2265
%2268 = getelementptr double, double* %16, i64 %2266
%2269 = getelementptr double, double* %196, i64 %2266
%2270 = bitcast double* %2269 to i8*
%2271 = icmp ult double* %2268, %197
%2272 = icmp ult i8* %25, %2270
%2273 = and i1 %2271, %2272
br i1 %2273, label %2348, label %2274
2274: ; preds = %2267
br i1 %362, label %2328, label %2275
2275: ; preds = %2274, %2275
%2276 = phi i64 [ %2325, %2275 ], [ 0, %2274 ]
%2277 = phi i64 [ %2326, %2275 ], [ 0, %2274 ]
%2278 = getelementptr inbounds double, double* %24, i64 %2276
%2279 = bitcast double* %2278 to <2 x double>*
%2280 = load <2 x double>, <2 x double>* %2279
%2281 = getelementptr inbounds double, double* %2278, i64 2
%2282 = bitcast double* %2281 to <2 x double>*
%2283 = load <2 x double>, <2 x double>* %2282
%2284 = add nsw i64 %2276, %2266
%2285 = getelementptr inbounds double, double* %16, i64 %2284
%2286 = bitcast double* %2285 to <2 x double>*
store <2 x double> %2280, <2 x double>* %2286
%2287 = getelementptr inbounds double, double* %2285, i64 2
%2288 = bitcast double* %2287 to <2 x double>*
store <2 x double> %2283, <2 x double>* %2288
%2289 = or i64 %2276, 4
%2290 = getelementptr inbounds double, double* %24, i64 %2289
%2291 = bitcast double* %2290 to <2 x double>*
%2292 = load <2 x double>, <2 x double>* %2291
%2293 = getelementptr inbounds double, double* %2290, i64 2
%2294 = bitcast double* %2293 to <2 x double>*
%2295 = load <2 x double>, <2 x double>* %2294
%2296 = add nsw i64 %2289, %2266
%2297 = getelementptr inbounds double, double* %16, i64 %2296
%2298 = bitcast double* %2297 to <2 x double>*
store <2 x double> %2292, <2 x double>* %2298
%2299 = getelementptr inbounds double, double* %2297, i64 2
%2300 = bitcast double* %2299 to <2 x double>*
store <2 x double> %2295, <2 x double>* %2300
%2301 = or i64 %2276, 8
%2302 = getelementptr inbounds double, double* %24, i64 %2301
%2303 = bitcast double* %2302 to <2 x double>*
%2304 = load <2 x double>, <2 x double>* %2303
%2305 = getelementptr inbounds double, double* %2302, i64 2
%2306 = bitcast double* %2305 to <2 x double>*
%2307 = load <2 x double>, <2 x double>* %2306
%2308 = add nsw i64 %2301, %2266
%2309 = getelementptr inbounds double, double* %16, i64 %2308
%2310 = bitcast double* %2309 to <2 x double>*
store <2 x double> %2304, <2 x double>* %2310
%2311 = getelementptr inbounds double, double* %2309, i64 2
%2312 = bitcast double* %2311 to <2 x double>*
store <2 x double> %2307, <2 x double>* %2312
%2313 = or i64 %2276, 12
%2314 = getelementptr inbounds double, double* %24, i64 %2313
%2315 = bitcast double* %2314 to <2 x double>*
%2316 = load <2 x double>, <2 x double>* %2315
%2317 = getelementptr inbounds double, double* %2314, i64 2
%2318 = bitcast double* %2317 to <2 x double>*
%2319 = load <2 x double>, <2 x double>* %2318
%2320 = add nsw i64 %2313, %2266
%2321 = getelementptr inbounds double, double* %16, i64 %2320
%2322 = bitcast double* %2321 to <2 x double>*
store <2 x double> %2316, <2 x double>* %2322
%2323 = getelementptr inbounds double, double* %2321, i64 2
%2324 = bitcast double* %2323 to <2 x double>*
store <2 x double> %2319, <2 x double>* %2324
%2325 = add nuw i64 %2276, 16
%2326 = add nuw i64 %2277, 4
%2327 = icmp eq i64 %2326, %363
br i1 %2327, label %2328, label %2275
2328: ; preds = %2275, %2274
%2329 = phi i64 [ 0, %2274 ], [ %2325, %2275 ]
br i1 %364, label %2347, label %2330
2330: ; preds = %2328, %2330
%2331 = phi i64 [ %2344, %2330 ], [ %2329, %2328 ]
%2332 = phi i64 [ %2345, %2330 ], [ 0, %2328 ]
%2333 = getelementptr inbounds double, double* %24, i64 %2331
%2334 = bitcast double* %2333 to <2 x double>*
%2335 = load <2 x double>, <2 x double>* %2334
%2336 = getelementptr inbounds double, double* %2333, i64 2
%2337 = bitcast double* %2336 to <2 x double>*
%2338 = load <2 x double>, <2 x double>* %2337
%2339 = add nsw i64 %2331, %2266
%2340 = getelementptr inbounds double, double* %16, i64 %2339
%2341 = bitcast double* %2340 to <2 x double>*
store <2 x double> %2335, <2 x double>* %2341
%2342 = getelementptr inbounds double, double* %2340, i64 2
%2343 = bitcast double* %2342 to <2 x double>*
store <2 x double> %2338, <2 x double>* %2343
%2344 = add nuw i64 %2331, 4
%2345 = add i64 %2332, 1
%2346 = icmp eq i64 %2345, %361
br i1 %2346, label %2347, label %2330
2347: ; preds = %2330, %2328
br i1 %365, label %2411, label %2348
2348: ; preds = %2267, %2265, %2347
%2349 = phi i64 [ 0, %2267 ], [ 0, %2265 ], [ %360, %2347 ]
%2350 = xor i64 %2349, -1
%2351 = add nsw i64 %2350, %156
br i1 %367, label %2362, label %2352
2352: ; preds = %2348, %2352
%2353 = phi i64 [ %2359, %2352 ], [ %2349, %2348 ]
%2354 = phi i64 [ %2360, %2352 ], [ 0, %2348 ]
%2355 = getelementptr inbounds double, double* %24, i64 %2353
%2356 = load double, double* %2355
%2357 = add nsw i64 %2353, %2266
%2358 = getelementptr inbounds double, double* %16, i64 %2357
store double %2356, double* %2358
%2359 = add nuw nsw i64 %2353, 1
%2360 = add i64 %2354, 1
%2361 = icmp eq i64 %2360, %366
br i1 %2361, label %2362, label %2352
2362: ; preds = %2352, %2348
%2363 = phi i64 [ %2349, %2348 ], [ %2359, %2352 ]
%2364 = icmp ult i64 %2351, 3
br i1 %2364, label %2411, label %2388
2365: ; preds = %2261, %2365
%2366 = phi i64 [ %2386, %2365 ], [ %2262, %2261 ]
%2367 = getelementptr inbounds double, double* %27, i64 %2366
%2368 = load double, double* %2367
%2369 = add nsw i64 %2366, %2165
%2370 = getelementptr inbounds double, double* %16, i64 %2369
store double %2368, double* %2370
%2371 = add nuw nsw i64 %2366, 1
%2372 = getelementptr inbounds double, double* %27, i64 %2371
%2373 = load double, double* %2372
%2374 = add nsw i64 %2371, %2165
%2375 = getelementptr inbounds double, double* %16, i64 %2374
store double %2373, double* %2375
%2376 = add nuw nsw i64 %2366, 2
%2377 = getelementptr inbounds double, double* %27, i64 %2376
%2378 = load double, double* %2377
%2379 = add nsw i64 %2376, %2165
%2380 = getelementptr inbounds double, double* %16, i64 %2379
store double %2378, double* %2380
%2381 = add nuw nsw i64 %2366, 3
%2382 = getelementptr inbounds double, double* %27, i64 %2381
%2383 = load double, double* %2382
%2384 = add nsw i64 %2381, %2165
%2385 = getelementptr inbounds double, double* %16, i64 %2384
store double %2383, double* %2385
%2386 = add nuw nsw i64 %2366, 4
%2387 = icmp eq i64 %2386, %169
br i1 %2387, label %2411, label %2365
2388: ; preds = %2362, %2388
%2389 = phi i64 [ %2409, %2388 ], [ %2363, %2362 ]
%2390 = getelementptr inbounds double, double* %24, i64 %2389
%2391 = load double, double* %2390
%2392 = add nsw i64 %2389, %2266
%2393 = getelementptr inbounds double, double* %16, i64 %2392
store double %2391, double* %2393
%2394 = add nuw nsw i64 %2389, 1
%2395 = getelementptr inbounds double, double* %24, i64 %2394
%2396 = load double, double* %2395
%2397 = add nsw i64 %2394, %2266
%2398 = getelementptr inbounds double, double* %16, i64 %2397
store double %2396, double* %2398
%2399 = add nuw nsw i64 %2389, 2
%2400 = getelementptr inbounds double, double* %24, i64 %2399
%2401 = load double, double* %2400
%2402 = add nsw i64 %2399, %2266
%2403 = getelementptr inbounds double, double* %16, i64 %2402
store double %2401, double* %2403
%2404 = add nuw nsw i64 %2389, 3
%2405 = getelementptr inbounds double, double* %24, i64 %2404
%2406 = load double, double* %2405
%2407 = add nsw i64 %2404, %2266
%2408 = getelementptr inbounds double, double* %16, i64 %2407
store double %2406, double* %2408
%2409 = add nuw nsw i64 %2389, 4
%2410 = icmp eq i64 %2409, %170
br i1 %2410, label %2411, label %2388
2411: ; preds = %2261, %2365, %2362, %2388, %2246, %2347, %2264, %2163
%2412 = phi double [ %2161, %2163 ], [ %1129, %2264 ], [ %1129, %2347 ], [ %2161, %2246 ], [ %1129, %2388 ], [ %1129, %2362 ], [ %2161, %2365 ], [ %2161, %2261 ]
%2413 = sext i32 %956 to i64
%2414 = getelementptr inbounds double, double* %19, i64 %2413
store double %2412, double* %2414
br label %2415
2415: ; preds = %2411, %2080
%2416 = phi i32 [ %2081, %2080 ], [ 1, %2411 ]
%2417 = icmp ugt i32 %2416, 1
br i1 %2417, label %2424, label %2418
2418: ; preds = %1953, %2415
%2419 = phi double [ %2082, %2415 ], [ %1954, %1953 ]
%2420 = phi i32 [ %2083, %2415 ], [ %1955, %1953 ]
%2421 = sext i32 %956 to i64
%2422 = getelementptr inbounds double, double* %19, i64 %2421
%2423 = load double, double* %2422
br label %2551
2424: ; preds = %2415
br i1 %41, label %2425, label %2548
2425: ; preds = %2424
%2426 = sext i32 %957 to i64
br i1 %368, label %2508, label %2427
2427: ; preds = %2425
%2428 = getelementptr double, double* %16, i64 %2426
%2429 = getelementptr double, double* %194, i64 %2426
%2430 = bitcast double* %2429 to i8*
%2431 = icmp ult double* %2428, %195
%2432 = icmp ult i8* %25, %2430
%2433 = and i1 %2431, %2432
br i1 %2433, label %2508, label %2434
2434: ; preds = %2427
br i1 %371, label %2488, label %2435
2435: ; preds = %2434, %2435
%2436 = phi i64 [ %2485, %2435 ], [ 0, %2434 ]
%2437 = phi i64 [ %2486, %2435 ], [ 0, %2434 ]
%2438 = getelementptr inbounds double, double* %24, i64 %2436
%2439 = bitcast double* %2438 to <2 x double>*
%2440 = load <2 x double>, <2 x double>* %2439
%2441 = getelementptr inbounds double, double* %2438, i64 2
%2442 = bitcast double* %2441 to <2 x double>*
%2443 = load <2 x double>, <2 x double>* %2442
%2444 = add nsw i64 %2436, %2426
%2445 = getelementptr inbounds double, double* %16, i64 %2444
%2446 = bitcast double* %2445 to <2 x double>*
store <2 x double> %2440, <2 x double>* %2446
%2447 = getelementptr inbounds double, double* %2445, i64 2
%2448 = bitcast double* %2447 to <2 x double>*
store <2 x double> %2443, <2 x double>* %2448
%2449 = or i64 %2436, 4
%2450 = getelementptr inbounds double, double* %24, i64 %2449
%2451 = bitcast double* %2450 to <2 x double>*
%2452 = load <2 x double>, <2 x double>* %2451
%2453 = getelementptr inbounds double, double* %2450, i64 2
%2454 = bitcast double* %2453 to <2 x double>*
%2455 = load <2 x double>, <2 x double>* %2454
%2456 = add nsw i64 %2449, %2426
%2457 = getelementptr inbounds double, double* %16, i64 %2456
%2458 = bitcast double* %2457 to <2 x double>*
store <2 x double> %2452, <2 x double>* %2458
%2459 = getelementptr inbounds double, double* %2457, i64 2
%2460 = bitcast double* %2459 to <2 x double>*
store <2 x double> %2455, <2 x double>* %2460
%2461 = or i64 %2436, 8
%2462 = getelementptr inbounds double, double* %24, i64 %2461
%2463 = bitcast double* %2462 to <2 x double>*
%2464 = load <2 x double>, <2 x double>* %2463
%2465 = getelementptr inbounds double, double* %2462, i64 2
%2466 = bitcast double* %2465 to <2 x double>*
%2467 = load <2 x double>, <2 x double>* %2466
%2468 = add nsw i64 %2461, %2426
%2469 = getelementptr inbounds double, double* %16, i64 %2468
%2470 = bitcast double* %2469 to <2 x double>*
store <2 x double> %2464, <2 x double>* %2470
%2471 = getelementptr inbounds double, double* %2469, i64 2
%2472 = bitcast double* %2471 to <2 x double>*
store <2 x double> %2467, <2 x double>* %2472
%2473 = or i64 %2436, 12
%2474 = getelementptr inbounds double, double* %24, i64 %2473
%2475 = bitcast double* %2474 to <2 x double>*
%2476 = load <2 x double>, <2 x double>* %2475
%2477 = getelementptr inbounds double, double* %2474, i64 2
%2478 = bitcast double* %2477 to <2 x double>*
%2479 = load <2 x double>, <2 x double>* %2478
%2480 = add nsw i64 %2473, %2426
%2481 = getelementptr inbounds double, double* %16, i64 %2480
%2482 = bitcast double* %2481 to <2 x double>*
store <2 x double> %2476, <2 x double>* %2482
%2483 = getelementptr inbounds double, double* %2481, i64 2
%2484 = bitcast double* %2483 to <2 x double>*
store <2 x double> %2479, <2 x double>* %2484
%2485 = add nuw i64 %2436, 16
%2486 = add nuw i64 %2437, 4
%2487 = icmp eq i64 %2486, %372
br i1 %2487, label %2488, label %2435
2488: ; preds = %2435, %2434
%2489 = phi i64 [ 0, %2434 ], [ %2485, %2435 ]
br i1 %373, label %2507, label %2490
2490: ; preds = %2488, %2490
%2491 = phi i64 [ %2504, %2490 ], [ %2489, %2488 ]
%2492 = phi i64 [ %2505, %2490 ], [ 0, %2488 ]
%2493 = getelementptr inbounds double, double* %24, i64 %2491
%2494 = bitcast double* %2493 to <2 x double>*
%2495 = load <2 x double>, <2 x double>* %2494
%2496 = getelementptr inbounds double, double* %2493, i64 2
%2497 = bitcast double* %2496 to <2 x double>*
%2498 = load <2 x double>, <2 x double>* %2497
%2499 = add nsw i64 %2491, %2426
%2500 = getelementptr inbounds double, double* %16, i64 %2499
%2501 = bitcast double* %2500 to <2 x double>*
store <2 x double> %2495, <2 x double>* %2501
%2502 = getelementptr inbounds double, double* %2500, i64 2
%2503 = bitcast double* %2502 to <2 x double>*
store <2 x double> %2498, <2 x double>* %2503
%2504 = add nuw i64 %2491, 4
%2505 = add i64 %2492, 1
%2506 = icmp eq i64 %2505, %370
br i1 %2506, label %2507, label %2490
2507: ; preds = %2490, %2488
br i1 %374, label %2548, label %2508
2508: ; preds = %2427, %2425, %2507
%2509 = phi i64 [ 0, %2427 ], [ 0, %2425 ], [ %369, %2507 ]
%2510 = xor i64 %2509, -1
%2511 = add nsw i64 %2510, %156
br i1 %376, label %2522, label %2512
2512: ; preds = %2508, %2512
%2513 = phi i64 [ %2519, %2512 ], [ %2509, %2508 ]
%2514 = phi i64 [ %2520, %2512 ], [ 0, %2508 ]
%2515 = getelementptr inbounds double, double* %24, i64 %2513
%2516 = load double, double* %2515
%2517 = add nsw i64 %2513, %2426
%2518 = getelementptr inbounds double, double* %16, i64 %2517
store double %2516, double* %2518
%2519 = add nuw nsw i64 %2513, 1
%2520 = add i64 %2514, 1
%2521 = icmp eq i64 %2520, %375
br i1 %2521, label %2522, label %2512
2522: ; preds = %2512, %2508
%2523 = phi i64 [ %2509, %2508 ], [ %2519, %2512 ]
%2524 = icmp ult i64 %2511, 3
br i1 %2524, label %2548, label %2525
2525: ; preds = %2522, %2525
%2526 = phi i64 [ %2546, %2525 ], [ %2523, %2522 ]
%2527 = getelementptr inbounds double, double* %24, i64 %2526
%2528 = load double, double* %2527
%2529 = add nsw i64 %2526, %2426
%2530 = getelementptr inbounds double, double* %16, i64 %2529
store double %2528, double* %2530
%2531 = add nuw nsw i64 %2526, 1
%2532 = getelementptr inbounds double, double* %24, i64 %2531
%2533 = load double, double* %2532
%2534 = add nsw i64 %2531, %2426
%2535 = getelementptr inbounds double, double* %16, i64 %2534
store double %2533, double* %2535
%2536 = add nuw nsw i64 %2526, 2
%2537 = getelementptr inbounds double, double* %24, i64 %2536
%2538 = load double, double* %2537
%2539 = add nsw i64 %2536, %2426
%2540 = getelementptr inbounds double, double* %16, i64 %2539
store double %2538, double* %2540
%2541 = add nuw nsw i64 %2526, 3
%2542 = getelementptr inbounds double, double* %24, i64 %2541
%2543 = load double, double* %2542
%2544 = add nsw i64 %2541, %2426
%2545 = getelementptr inbounds double, double* %16, i64 %2544
store double %2543, double* %2545
%2546 = add nuw nsw i64 %2526, 4
%2547 = icmp eq i64 %2546, %171
br i1 %2547, label %2548, label %2525
2548: ; preds = %2522, %2525, %2507, %2424
%2549 = sext i32 %956 to i64
%2550 = getelementptr inbounds double, double* %19, i64 %2549
store double %1129, double* %2550
br label %2551
2551: ; preds = %2418, %2548, %1538, %1565
%2552 = phi double [ %1539, %1538 ], [ %1129, %1565 ], [ %1129, %2548 ], [ %2423, %2418 ]
%2553 = phi double [ %930, %1538 ], [ %930, %1565 ], [ %2082, %2548 ], [ %2419, %2418 ]
%2554 = phi i32 [ %931, %1538 ], [ %931, %1565 ], [ %2083, %2548 ], [ %2420, %2418 ]
%2555 = fcmp olt double %2552, %2553
%2556 = select i1 %2555, double %2552, double %2553
%2557 = select i1 %2555, i32 %956, i32 %2554
br i1 %152, label %2666, label %2558
2558: ; preds = %2551
br i1 %413, label %2597, label %2559
2559: ; preds = %2558, %2559
%2560 = phi i64 [ %2594, %2559 ], [ 0, %2558 ]
%2561 = phi double [ %2593, %2559 ], [ 0.000000e+00, %2558 ]
%2562 = phi i64 [ %2595, %2559 ], [ 0, %2558 ]
%2563 = getelementptr inbounds double, double* %19, i64 %2560
%2564 = load double, double* %2563
%2565 = fadd double %2561, %2564
%2566 = or i64 %2560, 1
%2567 = getelementptr inbounds double, double* %19, i64 %2566
%2568 = load double, double* %2567
%2569 = fadd double %2565, %2568
%2570 = or i64 %2560, 2
%2571 = getelementptr inbounds double, double* %19, i64 %2570
%2572 = load double, double* %2571
%2573 = fadd double %2569, %2572
%2574 = or i64 %2560, 3
%2575 = getelementptr inbounds double, double* %19, i64 %2574
%2576 = load double, double* %2575
%2577 = fadd double %2573, %2576
%2578 = or i64 %2560, 4
%2579 = getelementptr inbounds double, double* %19, i64 %2578
%2580 = load double, double* %2579
%2581 = fadd double %2577, %2580
%2582 = or i64 %2560, 5
%2583 = getelementptr inbounds double, double* %19, i64 %2582
%2584 = load double, double* %2583
%2585 = fadd double %2581, %2584
%2586 = or i64 %2560, 6
%2587 = getelementptr inbounds double, double* %19, i64 %2586
%2588 = load double, double* %2587
%2589 = fadd double %2585, %2588
%2590 = or i64 %2560, 7
%2591 = getelementptr inbounds double, double* %19, i64 %2590
%2592 = load double, double* %2591
%2593 = fadd double %2589, %2592
%2594 = add nuw nsw i64 %2560, 8
%2595 = add i64 %2562, 8
%2596 = icmp eq i64 %2595, %414
br i1 %2596, label %2597, label %2559
2597: ; preds = %2559, %2558
%2598 = phi double [ undef, %2558 ], [ %2593, %2559 ]
%2599 = phi i64 [ 0, %2558 ], [ %2594, %2559 ]
%2600 = phi double [ 0.000000e+00, %2558 ], [ %2593, %2559 ]
br i1 %415, label %2611, label %2601
2601: ; preds = %2597, %2601
%2602 = phi i64 [ %2608, %2601 ], [ %2599, %2597 ]
%2603 = phi double [ %2607, %2601 ], [ %2600, %2597 ]
%2604 = phi i64 [ %2609, %2601 ], [ 0, %2597 ]
%2605 = getelementptr inbounds double, double* %19, i64 %2602
%2606 = load double, double* %2605
%2607 = fadd double %2603, %2606
%2608 = add nuw nsw i64 %2602, 1
%2609 = add i64 %2604, 1
%2610 = icmp eq i64 %2609, %412
br i1 %2610, label %2611, label %2601
2611: ; preds = %2601, %2597
%2612 = phi double [ %2598, %2597 ], [ %2607, %2601 ]
%2613 = fdiv double %2612, %154
br i1 %152, label %2666, label %2614
2614: ; preds = %2611
br i1 %417, label %2649, label %2615
2615: ; preds = %2614, %2615
%2616 = phi i64 [ %2646, %2615 ], [ 0, %2614 ]
%2617 = phi double [ %2645, %2615 ], [ 0.000000e+00, %2614 ]
%2618 = phi i64 [ %2647, %2615 ], [ 0, %2614 ]
%2619 = getelementptr inbounds double, double* %19, i64 %2616
%2620 = load double, double* %2619
%2621 = fsub double %2620, %2613
%2622 = tail call i64 @pow(double %2621, double 2.000000e+00)
%2623 = sitofp i64 %2622 to double
%2624 = fadd double %2617, %2623
%2625 = or i64 %2616, 1
%2626 = getelementptr inbounds double, double* %19, i64 %2625
%2627 = load double, double* %2626
%2628 = fsub double %2627, %2613
%2629 = tail call i64 @pow(double %2628, double 2.000000e+00)
%2630 = sitofp i64 %2629 to double
%2631 = fadd double %2624, %2630
%2632 = or i64 %2616, 2
%2633 = getelementptr inbounds double, double* %19, i64 %2632
%2634 = load double, double* %2633
%2635 = fsub double %2634, %2613
%2636 = tail call i64 @pow(double %2635, double 2.000000e+00)
%2637 = sitofp i64 %2636 to double
%2638 = fadd double %2631, %2637
%2639 = or i64 %2616, 3
%2640 = getelementptr inbounds double, double* %19, i64 %2639
%2641 = load double, double* %2640
%2642 = fsub double %2641, %2613
%2643 = tail call i64 @pow(double %2642, double 2.000000e+00)
%2644 = sitofp i64 %2643 to double
%2645 = fadd double %2638, %2644
%2646 = add nuw nsw i64 %2616, 4
%2647 = add i64 %2618, 4
%2648 = icmp eq i64 %2647, %418
br i1 %2648, label %2649, label %2615
2649: ; preds = %2615, %2614
%2650 = phi double [ undef, %2614 ], [ %2645, %2615 ]
%2651 = phi i64 [ 0, %2614 ], [ %2646, %2615 ]
%2652 = phi double [ 0.000000e+00, %2614 ], [ %2645, %2615 ]
br i1 %419, label %2666, label %2653
2653: ; preds = %2649, %2653
%2654 = phi i64 [ %2663, %2653 ], [ %2651, %2649 ]
%2655 = phi double [ %2662, %2653 ], [ %2652, %2649 ]
%2656 = phi i64 [ %2664, %2653 ], [ 0, %2649 ]
%2657 = getelementptr inbounds double, double* %19, i64 %2654
%2658 = load double, double* %2657
%2659 = fsub double %2658, %2613
%2660 = tail call i64 @pow(double %2659, double 2.000000e+00)
%2661 = sitofp i64 %2660 to double
%2662 = fadd double %2655, %2661
%2663 = add nuw nsw i64 %2654, 1
%2664 = add i64 %2656, 1
%2665 = icmp eq i64 %2664, %416
br i1 %2665, label %2666, label %2653
2666: ; preds = %2649, %2653, %2551, %2611
%2667 = phi double [ 0.000000e+00, %2611 ], [ 0.000000e+00, %2551 ], [ %2650, %2649 ], [ %2662, %2653 ]
%2668 = tail call double @sqrt(double %2667)
%2669 = tail call double @llvm.fabs.f64(double %2668)
%2670 = fcmp olt double %2669, %7
%2671 = select i1 %2670, i32 1, i32 %932
%2672 = fcmp ogt double %2669, %7
br i1 %2672, label %925, label %2673
2673: ; preds = %925, %2666, %899
%2674 = phi i32 [ %794, %899 ], [ %2557, %2666 ], [ %2557, %925 ]
%2675 = phi i32 [ 0, %899 ], [ %2671, %2666 ], [ %2671, %925 ]
%2676 = phi double [ %461, %899 ], [ %2668, %2666 ], [ %2668, %925 ]
%2677 = mul i32 %2674, %2
br label %2678
2678: ; preds = %2673, %896
%2679 = phi i32 [ %2677, %2673 ], [ %795, %896 ]
%2680 = phi i32 [ %2674, %2673 ], [ %794, %896 ]
%2681 = phi i32 [ %2675, %2673 ], [ 0, %896 ]
%2682 = phi double [ %2676, %2673 ], [ %461, %896 ]
br i1 %41, label %2683, label %2830
2683: ; preds = %2678
%2684 = sext i32 %2679 to i64
br i1 %420, label %2766, label %2685
2685: ; preds = %2683
%2686 = getelementptr double, double* %16, i64 %2684
%2687 = getelementptr double, double* %183, i64 %2684
%2688 = bitcast double* %2687 to i8*
%2689 = icmp ult i8* %40, %2688
%2690 = icmp ult double* %2686, %182
%2691 = and i1 %2689, %2690
br i1 %2691, label %2766, label %2692
2692: ; preds = %2685
br i1 %423, label %2746, label %2693
2693: ; preds = %2692, %2693
%2694 = phi i64 [ %2743, %2693 ], [ 0, %2692 ]
%2695 = phi i64 [ %2744, %2693 ], [ 0, %2692 ]
%2696 = add nsw i64 %2694, %2684
%2697 = getelementptr inbounds double, double* %16, i64 %2696
%2698 = bitcast double* %2697 to <2 x double>*
%2699 = load <2 x double>, <2 x double>* %2698
%2700 = getelementptr inbounds double, double* %2697, i64 2
%2701 = bitcast double* %2700 to <2 x double>*
%2702 = load <2 x double>, <2 x double>* %2701
%2703 = getelementptr inbounds double, double* %39, i64 %2694
%2704 = bitcast double* %2703 to <2 x double>*
store <2 x double> %2699, <2 x double>* %2704
%2705 = getelementptr inbounds double, double* %2703, i64 2
%2706 = bitcast double* %2705 to <2 x double>*
store <2 x double> %2702, <2 x double>* %2706
%2707 = or i64 %2694, 4
%2708 = add nsw i64 %2707, %2684
%2709 = getelementptr inbounds double, double* %16, i64 %2708
%2710 = bitcast double* %2709 to <2 x double>*
%2711 = load <2 x double>, <2 x double>* %2710
%2712 = getelementptr inbounds double, double* %2709, i64 2
%2713 = bitcast double* %2712 to <2 x double>*
%2714 = load <2 x double>, <2 x double>* %2713
%2715 = getelementptr inbounds double, double* %39, i64 %2707
%2716 = bitcast double* %2715 to <2 x double>*
store <2 x double> %2711, <2 x double>* %2716
%2717 = getelementptr inbounds double, double* %2715, i64 2
%2718 = bitcast double* %2717 to <2 x double>*
store <2 x double> %2714, <2 x double>* %2718
%2719 = or i64 %2694, 8
%2720 = add nsw i64 %2719, %2684
%2721 = getelementptr inbounds double, double* %16, i64 %2720
%2722 = bitcast double* %2721 to <2 x double>*
%2723 = load <2 x double>, <2 x double>* %2722
%2724 = getelementptr inbounds double, double* %2721, i64 2
%2725 = bitcast double* %2724 to <2 x double>*
%2726 = load <2 x double>, <2 x double>* %2725
%2727 = getelementptr inbounds double, double* %39, i64 %2719
%2728 = bitcast double* %2727 to <2 x double>*
store <2 x double> %2723, <2 x double>* %2728
%2729 = getelementptr inbounds double, double* %2727, i64 2
%2730 = bitcast double* %2729 to <2 x double>*
store <2 x double> %2726, <2 x double>* %2730
%2731 = or i64 %2694, 12
%2732 = add nsw i64 %2731, %2684
%2733 = getelementptr inbounds double, double* %16, i64 %2732
%2734 = bitcast double* %2733 to <2 x double>*
%2735 = load <2 x double>, <2 x double>* %2734
%2736 = getelementptr inbounds double, double* %2733, i64 2
%2737 = bitcast double* %2736 to <2 x double>*
%2738 = load <2 x double>, <2 x double>* %2737
%2739 = getelementptr inbounds double, double* %39, i64 %2731
%2740 = bitcast double* %2739 to <2 x double>*
store <2 x double> %2735, <2 x double>* %2740
%2741 = getelementptr inbounds double, double* %2739, i64 2
%2742 = bitcast double* %2741 to <2 x double>*
store <2 x double> %2738, <2 x double>* %2742
%2743 = add nuw i64 %2694, 16
%2744 = add nuw i64 %2695, 4
%2745 = icmp eq i64 %2744, %424
br i1 %2745, label %2746, label %2693
2746: ; preds = %2693, %2692
%2747 = phi i64 [ 0, %2692 ], [ %2743, %2693 ]
br i1 %425, label %2765, label %2748
2748: ; preds = %2746, %2748
%2749 = phi i64 [ %2762, %2748 ], [ %2747, %2746 ]
%2750 = phi i64 [ %2763, %2748 ], [ 0, %2746 ]
%2751 = add nsw i64 %2749, %2684
%2752 = getelementptr inbounds double, double* %16, i64 %2751
%2753 = bitcast double* %2752 to <2 x double>*
%2754 = load <2 x double>, <2 x double>* %2753
%2755 = getelementptr inbounds double, double* %2752, i64 2
%2756 = bitcast double* %2755 to <2 x double>*
%2757 = load <2 x double>, <2 x double>* %2756
%2758 = getelementptr inbounds double, double* %39, i64 %2749
%2759 = bitcast double* %2758 to <2 x double>*
store <2 x double> %2754, <2 x double>* %2759
%2760 = getelementptr inbounds double, double* %2758, i64 2
%2761 = bitcast double* %2760 to <2 x double>*
store <2 x double> %2757, <2 x double>* %2761
%2762 = add nuw i64 %2749, 4
%2763 = add i64 %2750, 1
%2764 = icmp eq i64 %2763, %422
br i1 %2764, label %2765, label %2748
2765: ; preds = %2748, %2746
br i1 %426, label %2806, label %2766
2766: ; preds = %2685, %2683, %2765
%2767 = phi i64 [ 0, %2685 ], [ 0, %2683 ], [ %421, %2765 ]
%2768 = xor i64 %2767, -1
%2769 = add nsw i64 %2768, %156
br i1 %428, label %2780, label %2770
2770: ; preds = %2766, %2770
%2771 = phi i64 [ %2777, %2770 ], [ %2767, %2766 ]
%2772 = phi i64 [ %2778, %2770 ], [ 0, %2766 ]
%2773 = add nsw i64 %2771, %2684
%2774 = getelementptr inbounds double, double* %16, i64 %2773
%2775 = load double, double* %2774
%2776 = getelementptr inbounds double, double* %39, i64 %2771
store double %2775, double* %2776
%2777 = add nuw nsw i64 %2771, 1
%2778 = add i64 %2772, 1
%2779 = icmp eq i64 %2778, %427
br i1 %2779, label %2780, label %2770
2780: ; preds = %2770, %2766
%2781 = phi i64 [ %2767, %2766 ], [ %2777, %2770 ]
%2782 = icmp ult i64 %2769, 3
br i1 %2782, label %2806, label %2783
2783: ; preds = %2780, %2783
%2784 = phi i64 [ %2804, %2783 ], [ %2781, %2780 ]
%2785 = add nsw i64 %2784, %2684
%2786 = getelementptr inbounds double, double* %16, i64 %2785
%2787 = load double, double* %2786
%2788 = getelementptr inbounds double, double* %39, i64 %2784
store double %2787, double* %2788
%2789 = add nuw nsw i64 %2784, 1
%2790 = add nsw i64 %2789, %2684
%2791 = getelementptr inbounds double, double* %16, i64 %2790
%2792 = load double, double* %2791
%2793 = getelementptr inbounds double, double* %39, i64 %2789
store double %2792, double* %2793
%2794 = add nuw nsw i64 %2784, 2
%2795 = add nsw i64 %2794, %2684
%2796 = getelementptr inbounds double, double* %16, i64 %2795
%2797 = load double, double* %2796
%2798 = getelementptr inbounds double, double* %39, i64 %2794
store double %2797, double* %2798
%2799 = add nuw nsw i64 %2784, 3
%2800 = add nsw i64 %2799, %2684
%2801 = getelementptr inbounds double, double* %16, i64 %2800
%2802 = load double, double* %2801
%2803 = getelementptr inbounds double, double* %39, i64 %2799
store double %2802, double* %2803
%2804 = add nuw nsw i64 %2784, 4
%2805 = icmp eq i64 %2804, %175
br i1 %2805, label %2806, label %2783
2806: ; preds = %2780, %2783, %2765
%2807 = sext i32 %2680 to i64
%2808 = getelementptr inbounds double, double* %19, i64 %2807
%2809 = load double, double* %2808
br i1 %41, label %2810, label %2830
2810: ; preds = %2806
%2811 = add i32 %155, %2681
br label %2812
2812: ; preds = %2810, %2827
%2813 = phi i64 [ 0, %2810 ], [ %2828, %2827 ]
%2814 = getelementptr inbounds double, double* %3, i64 %2813
%2815 = load double, double* %2814
%2816 = fmul double %2815, 1.000000e-03
%2817 = getelementptr inbounds double, double* %39, i64 %2813
%2818 = load double, double* %2817
%2819 = fadd double %2818, %2816
store double %2819, double* %2817
%2820 = tail call double %0(double* %39, i32 %2)
%2821 = fcmp olt double %2820, %2809
br i1 %2821, label %2830, label %2822
2822: ; preds = %2812
%2823 = load double, double* %2817
%2824 = tail call double @llvm.fmuladd.f64(double %2816, double -2.000000e+00, double %2823)
store double %2824, double* %2817
%2825 = tail call double %0(double* %39, i32 %2)
%2826 = fcmp olt double %2825, %2809
br i1 %2826, label %2830, label %2827
2827: ; preds = %2822
%2828 = add nuw nsw i64 %2813, 1
%2829 = icmp eq i64 %2828, %176
br i1 %2829, label %2830, label %2812
2830: ; preds = %2827, %2812, %2822, %2678, %2806
%2831 = phi double [ %463, %2806 ], [ %463, %2678 ], [ %2816, %2822 ], [ %2816, %2812 ], [ %2816, %2827 ]
%2832 = phi i32 [ %2681, %2806 ], [ %2681, %2678 ], [ %2811, %2827 ], [ 0, %2812 ], [ 0, %2822 ]
%2833 = icmp ne i32 %2832, 0
%2834 = or i1 %2833, %151
%2835 = select i1 %2833, double %2831, double 1.000000e-03
%2836 = select i1 %2833, double %2682, double 1.000000e+00
br i1 %2834, label %2943, label %2837
2837: ; preds = %2830
%2838 = select i1 %429, i1 true, i1 %432
br i1 %2838, label %2908, label %2839
2839: ; preds = %2837
br i1 %435, label %2889, label %2840
2840: ; preds = %2839, %2840
%2841 = phi i64 [ %2886, %2840 ], [ 0, %2839 ]
%2842 = phi i64 [ %2887, %2840 ], [ 0, %2839 ]
%2843 = getelementptr inbounds double, double* %39, i64 %2841
%2844 = bitcast double* %2843 to <2 x double>*
%2845 = load <2 x double>, <2 x double>* %2844
%2846 = getelementptr inbounds double, double* %2843, i64 2
%2847 = bitcast double* %2846 to <2 x double>*
%2848 = load <2 x double>, <2 x double>* %2847
%2849 = getelementptr inbounds double, double* %36, i64 %2841
%2850 = bitcast double* %2849 to <2 x double>*
store <2 x double> %2845, <2 x double>* %2850
%2851 = getelementptr inbounds double, double* %2849, i64 2
%2852 = bitcast double* %2851 to <2 x double>*
store <2 x double> %2848, <2 x double>* %2852
%2853 = or i64 %2841, 4
%2854 = getelementptr inbounds double, double* %39, i64 %2853
%2855 = bitcast double* %2854 to <2 x double>*
%2856 = load <2 x double>, <2 x double>* %2855
%2857 = getelementptr inbounds double, double* %2854, i64 2
%2858 = bitcast double* %2857 to <2 x double>*
%2859 = load <2 x double>, <2 x double>* %2858
%2860 = getelementptr inbounds double, double* %36, i64 %2853
%2861 = bitcast double* %2860 to <2 x double>*
store <2 x double> %2856, <2 x double>* %2861
%2862 = getelementptr inbounds double, double* %2860, i64 2
%2863 = bitcast double* %2862 to <2 x double>*
store <2 x double> %2859, <2 x double>* %2863
%2864 = or i64 %2841, 8
%2865 = getelementptr inbounds double, double* %39, i64 %2864
%2866 = bitcast double* %2865 to <2 x double>*
%2867 = load <2 x double>, <2 x double>* %2866
%2868 = getelementptr inbounds double, double* %2865, i64 2
%2869 = bitcast double* %2868 to <2 x double>*
%2870 = load <2 x double>, <2 x double>* %2869
%2871 = getelementptr inbounds double, double* %36, i64 %2864
%2872 = bitcast double* %2871 to <2 x double>*
store <2 x double> %2867, <2 x double>* %2872
%2873 = getelementptr inbounds double, double* %2871, i64 2
%2874 = bitcast double* %2873 to <2 x double>*
store <2 x double> %2870, <2 x double>* %2874
%2875 = or i64 %2841, 12
%2876 = getelementptr inbounds double, double* %39, i64 %2875
%2877 = bitcast double* %2876 to <2 x double>*
%2878 = load <2 x double>, <2 x double>* %2877
%2879 = getelementptr inbounds double, double* %2876, i64 2
%2880 = bitcast double* %2879 to <2 x double>*
%2881 = load <2 x double>, <2 x double>* %2880
%2882 = getelementptr inbounds double, double* %36, i64 %2875
%2883 = bitcast double* %2882 to <2 x double>*
store <2 x double> %2878, <2 x double>* %2883
%2884 = getelementptr inbounds double, double* %2882, i64 2
%2885 = bitcast double* %2884 to <2 x double>*
store <2 x double> %2881, <2 x double>* %2885
%2886 = add nuw i64 %2841, 16
%2887 = add nuw i64 %2842, 4
%2888 = icmp eq i64 %2887, %436
br i1 %2888, label %2889, label %2840
2889: ; preds = %2840, %2839
%2890 = phi i64 [ 0, %2839 ], [ %2886, %2840 ]
br i1 %437, label %2907, label %2891
2891: ; preds = %2889, %2891
%2892 = phi i64 [ %2904, %2891 ], [ %2890, %2889 ]
%2893 = phi i64 [ %2905, %2891 ], [ 0, %2889 ]
%2894 = getelementptr inbounds double, double* %39, i64 %2892
%2895 = bitcast double* %2894 to <2 x double>*
%2896 = load <2 x double>, <2 x double>* %2895
%2897 = getelementptr inbounds double, double* %2894, i64 2
%2898 = bitcast double* %2897 to <2 x double>*
%2899 = load <2 x double>, <2 x double>* %2898
%2900 = getelementptr inbounds double, double* %36, i64 %2892
%2901 = bitcast double* %2900 to <2 x double>*
store <2 x double> %2896, <2 x double>* %2901
%2902 = getelementptr inbounds double, double* %2900, i64 2
%2903 = bitcast double* %2902 to <2 x double>*
store <2 x double> %2899, <2 x double>* %2903
%2904 = add nuw i64 %2892, 4
%2905 = add i64 %2893, 1
%2906 = icmp eq i64 %2905, %434
br i1 %2906, label %2907, label %2891
2907: ; preds = %2891, %2889
br i1 %438, label %2943, label %2908
2908: ; preds = %2837, %2907
%2909 = phi i64 [ 0, %2837 ], [ %433, %2907 ]
%2910 = xor i64 %2909, -1
%2911 = add nsw i64 %2910, %156
br i1 %440, label %2921, label %2912
2912: ; preds = %2908, %2912
%2913 = phi i64 [ %2918, %2912 ], [ %2909, %2908 ]
%2914 = phi i64 [ %2919, %2912 ], [ 0, %2908 ]
%2915 = getelementptr inbounds double, double* %39, i64 %2913
%2916 = load double, double* %2915
%2917 = getelementptr inbounds double, double* %36, i64 %2913
store double %2916, double* %2917
%2918 = add nuw nsw i64 %2913, 1
%2919 = add i64 %2914, 1
%2920 = icmp eq i64 %2919, %439
br i1 %2920, label %2921, label %2912
2921: ; preds = %2912, %2908
%2922 = phi i64 [ %2909, %2908 ], [ %2918, %2912 ]
%2923 = icmp ult i64 %2911, 3
br i1 %2923, label %2943, label %2924
2924: ; preds = %2921, %2924
%2925 = phi i64 [ %2941, %2924 ], [ %2922, %2921 ]
%2926 = getelementptr inbounds double, double* %39, i64 %2925
%2927 = load double, double* %2926
%2928 = getelementptr inbounds double, double* %36, i64 %2925
store double %2927, double* %2928
%2929 = add nuw nsw i64 %2925, 1
%2930 = getelementptr inbounds double, double* %39, i64 %2929
%2931 = load double, double* %2930
%2932 = getelementptr inbounds double, double* %36, i64 %2929
store double %2931, double* %2932
%2933 = add nuw nsw i64 %2925, 2
%2934 = getelementptr inbounds double, double* %39, i64 %2933
%2935 = load double, double* %2934
%2936 = getelementptr inbounds double, double* %36, i64 %2933
store double %2935, double* %2936
%2937 = add nuw nsw i64 %2925, 3
%2938 = getelementptr inbounds double, double* %39, i64 %2937
%2939 = load double, double* %2938
%2940 = getelementptr inbounds double, double* %36, i64 %2937
store double %2939, double* %2940
%2941 = add nuw nsw i64 %2925, 4
%2942 = icmp eq i64 %2941, %177
br i1 %2942, label %2943, label %2924
2943: ; preds = %2921, %2924, %2907, %2830
%2944 = phi double [ %2835, %2830 ], [ 1.000000e-03, %2907 ], [ 1.000000e-03, %2924 ], [ 1.000000e-03, %2921 ]
%2945 = phi double [ %2836, %2830 ], [ 1.000000e+00, %2907 ], [ 1.000000e+00, %2924 ], [ 1.000000e+00, %2921 ]
%2946 = icmp eq i32 %2832, 0
br i1 %2946, label %460, label %2947
2947: ; preds = %2943, %460
br i1 %41, label %2948, label %3083
2948: ; preds = %2947
%2949 = zext i32 %11 to i64
%2950 = zext i32 %2 to i64
%2951 = icmp ult i32 %2, 4
br i1 %2951, label %3041, label %2952
2952: ; preds = %2948
%2953 = getelementptr double, double* %8, i64 %156
%2954 = getelementptr double, double* %16, i64 %2949
%2955 = add nuw nsw i64 %156, %2949
%2956 = getelementptr double, double* %16, i64 %2955
%2957 = icmp ugt double* %2956, %8
%2958 = icmp ult double* %2954, %2953
%2959 = and i1 %2957, %2958
br i1 %2959, label %3041, label %2960
2960: ; preds = %2952
%2961 = and i64 %156, 4294967292
%2962 = and i64 %231, 3
%2963 = icmp ult i64 %229, 12
br i1 %2963, label %3019, label %2964
2964: ; preds = %2960
%2965 = and i64 %231, 9223372036854775804
br label %2966
2966: ; preds = %2966, %2964
%2967 = phi i64 [ 0, %2964 ], [ %3016, %2966 ]
%2968 = phi i64 [ 0, %2964 ], [ %3017, %2966 ]
%2969 = add nuw nsw i64 %2967, %2949
%2970 = getelementptr inbounds double, double* %16, i64 %2969
%2971 = bitcast double* %2970 to <2 x double>*
%2972 = load <2 x double>, <2 x double>* %2971
%2973 = getelementptr inbounds double, double* %2970, i64 2
%2974 = bitcast double* %2973 to <2 x double>*
%2975 = load <2 x double>, <2 x double>* %2974
%2976 = getelementptr inbounds double, double* %8, i64 %2967
%2977 = bitcast double* %2976 to <2 x double>*
store <2 x double> %2972, <2 x double>* %2977
%2978 = getelementptr inbounds double, double* %2976, i64 2
%2979 = bitcast double* %2978 to <2 x double>*
store <2 x double> %2975, <2 x double>* %2979
%2980 = or i64 %2967, 4
%2981 = add nuw nsw i64 %2980, %2949
%2982 = getelementptr inbounds double, double* %16, i64 %2981
%2983 = bitcast double* %2982 to <2 x double>*
%2984 = load <2 x double>, <2 x double>* %2983
%2985 = getelementptr inbounds double, double* %2982, i64 2
%2986 = bitcast double* %2985 to <2 x double>*
%2987 = load <2 x double>, <2 x double>* %2986
%2988 = getelementptr inbounds double, double* %8, i64 %2980
%2989 = bitcast double* %2988 to <2 x double>*
store <2 x double> %2984, <2 x double>* %2989
%2990 = getelementptr inbounds double, double* %2988, i64 2
%2991 = bitcast double* %2990 to <2 x double>*
store <2 x double> %2987, <2 x double>* %2991
%2992 = or i64 %2967, 8
%2993 = add nuw nsw i64 %2992, %2949
%2994 = getelementptr inbounds double, double* %16, i64 %2993
%2995 = bitcast double* %2994 to <2 x double>*
%2996 = load <2 x double>, <2 x double>* %2995
%2997 = getelementptr inbounds double, double* %2994, i64 2
%2998 = bitcast double* %2997 to <2 x double>*
%2999 = load <2 x double>, <2 x double>* %2998
%3000 = getelementptr inbounds double, double* %8, i64 %2992
%3001 = bitcast double* %3000 to <2 x double>*
store <2 x double> %2996, <2 x double>* %3001
%3002 = getelementptr inbounds double, double* %3000, i64 2
%3003 = bitcast double* %3002 to <2 x double>*
store <2 x double> %2999, <2 x double>* %3003
%3004 = or i64 %2967, 12
%3005 = add nuw nsw i64 %3004, %2949
%3006 = getelementptr inbounds double, double* %16, i64 %3005
%3007 = bitcast double* %3006 to <2 x double>*
%3008 = load <2 x double>, <2 x double>* %3007
%3009 = getelementptr inbounds double, double* %3006, i64 2
%3010 = bitcast double* %3009 to <2 x double>*
%3011 = load <2 x double>, <2 x double>* %3010
%3012 = getelementptr inbounds double, double* %8, i64 %3004
%3013 = bitcast double* %3012 to <2 x double>*
store <2 x double> %3008, <2 x double>* %3013
%3014 = getelementptr inbounds double, double* %3012, i64 2
%3015 = bitcast double* %3014 to <2 x double>*
store <2 x double> %3011, <2 x double>* %3015
%3016 = add nuw i64 %2967, 16
%3017 = add nuw i64 %2968, 4
%3018 = icmp eq i64 %3017, %2965
br i1 %3018, label %3019, label %2966
3019: ; preds = %2966, %2960
%3020 = phi i64 [ 0, %2960 ], [ %3016, %2966 ]
%3021 = icmp eq i64 %2962, 0
br i1 %3021, label %3039, label %3022
3022: ; preds = %3019, %3022
%3023 = phi i64 [ %3036, %3022 ], [ %3020, %3019 ]
%3024 = phi i64 [ %3037, %3022 ], [ 0, %3019 ]
%3025 = add nuw nsw i64 %3023, %2949
%3026 = getelementptr inbounds double, double* %16, i64 %3025
%3027 = bitcast double* %3026 to <2 x double>*
%3028 = load <2 x double>, <2 x double>* %3027
%3029 = getelementptr inbounds double, double* %3026, i64 2
%3030 = bitcast double* %3029 to <2 x double>*
%3031 = load <2 x double>, <2 x double>* %3030
%3032 = getelementptr inbounds double, double* %8, i64 %3023
%3033 = bitcast double* %3032 to <2 x double>*
store <2 x double> %3028, <2 x double>* %3033
%3034 = getelementptr inbounds double, double* %3032, i64 2
%3035 = bitcast double* %3034 to <2 x double>*
store <2 x double> %3031, <2 x double>* %3035
%3036 = add nuw i64 %3023, 4
%3037 = add i64 %3024, 1
%3038 = icmp eq i64 %3037, %2962
br i1 %3038, label %3039, label %3022
3039: ; preds = %3022, %3019
%3040 = icmp eq i64 %2961, %156
br i1 %3040, label %3083, label %3041
3041: ; preds = %2952, %2948, %3039
%3042 = phi i64 [ 0, %2952 ], [ 0, %2948 ], [ %2961, %3039 ]
%3043 = xor i64 %3042, -1
%3044 = add nsw i64 %3043, %156
%3045 = and i64 %156, 3
%3046 = icmp eq i64 %3045, 0
br i1 %3046, label %3057, label %3047
3047: ; preds = %3041, %3047
%3048 = phi i64 [ %3054, %3047 ], [ %3042, %3041 ]
%3049 = phi i64 [ %3055, %3047 ], [ 0, %3041 ]
%3050 = add nuw nsw i64 %3048, %2949
%3051 = getelementptr inbounds double, double* %16, i64 %3050
%3052 = load double, double* %3051
%3053 = getelementptr inbounds double, double* %8, i64 %3048
store double %3052, double* %3053
%3054 = add nuw nsw i64 %3048, 1
%3055 = add i64 %3049, 1
%3056 = icmp eq i64 %3055, %3045
br i1 %3056, label %3057, label %3047
3057: ; preds = %3047, %3041
%3058 = phi i64 [ %3042, %3041 ], [ %3054, %3047 ]
%3059 = icmp ult i64 %3044, 3
br i1 %3059, label %3083, label %3060
3060: ; preds = %3057, %3060
%3061 = phi i64 [ %3081, %3060 ], [ %3058, %3057 ]
%3062 = add nuw nsw i64 %3061, %2949
%3063 = getelementptr inbounds double, double* %16, i64 %3062
%3064 = load double, double* %3063
%3065 = getelementptr inbounds double, double* %8, i64 %3061
store double %3064, double* %3065
%3066 = add nuw nsw i64 %3061, 1
%3067 = add nuw nsw i64 %3066, %2949
%3068 = getelementptr inbounds double, double* %16, i64 %3067
%3069 = load double, double* %3068
%3070 = getelementptr inbounds double, double* %8, i64 %3066
store double %3069, double* %3070
%3071 = add nuw nsw i64 %3061, 2
%3072 = add nuw nsw i64 %3071, %2949
%3073 = getelementptr inbounds double, double* %16, i64 %3072
%3074 = load double, double* %3073
%3075 = getelementptr inbounds double, double* %8, i64 %3071
store double %3074, double* %3075
%3076 = add nuw nsw i64 %3061, 3
%3077 = add nuw nsw i64 %3076, %2949
%3078 = getelementptr inbounds double, double* %16, i64 %3077
%3079 = load double, double* %3078
%3080 = getelementptr inbounds double, double* %8, i64 %3076
store double %3079, double* %3080
%3081 = add nuw nsw i64 %3061, 4
%3082 = icmp eq i64 %3081, %2950
br i1 %3082, label %3083, label %3060
3083: ; preds = %3057, %3060, %3039, %2947
%3084 = load i32, i32* %6
%3085 = icmp slt i32 %3084, %5
%3086 = select i1 %3085, i32 1, i32 4
%3087 = tail call i32 @free(double* %19)
%3088 = tail call i32 @free(double* %16)
%3089 = tail call i32 @free(double* %21)
%3090 = tail call i32 @free(double* %24)
%3091 = tail call i32 @free(double* %27)
%3092 = tail call i32 @free(double* %30)
%3093 = tail call i32 @free(double* %33)
%3094 = tail call i32 @free(double* %36)
%3095 = tail call i32 @free(double* %39)
ret i32 %3086
}