#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 */
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ polint(float *, float *, int, float, float *, float *);
int /*<<< orphan*/ spline(float *, float *, int, float, float, float *);
int /*<<< orphan*/ splint(float *, float *, float *, int, float, float *);
void interpolation(float *x, float *z, int nxp, int nx, int poly, int *pminx,
                   int *pmaxx, float dx, float **cp, float **cs, float **ro,
                   int nvel, float *interface) {
  int i, j, ndeltx, np;
  float deltx, deltz, xprev, zprev, minx, maxx;
  float deltcp, deltcs, deltro, cpprev, csprev, roprev;
  float *xa, *za, dyp, xp, yp1, ypn, *y2;
  if (poly == 0) {
    np = 0;
    xprev = zprev = 0.0;
    minx = nx * dx;
    maxx = 0;
    for (i = 0; i < nxp; i++) {
      if (x[i] < minx) {
        xprev = x[i];
        minx = x[i];
        *pminx =
            ((int)((minx / dx) > 0.0 ? (minx / dx) + 0.5 : (minx / dx) - 0.5));
        np = *pminx;
      }
      if (x[i] > maxx) {
        maxx = x[i];
        *pmaxx =
            ((((int)(((maxx + dx) / dx) > 0.0 ? ((maxx + dx) / dx) + 0.5
                                              : ((maxx + dx) / dx) - 0.5))) <
                     (nx)
                 ? (((int)(((maxx + dx) / dx) > 0.0
                               ? ((maxx + dx) / dx) + 0.5
                               : ((maxx + dx) / dx) - 0.5)))
                 : (nx));
      }
      deltx = x[i] - xprev;
      deltz = z[i] - zprev;
      if (i == 0)
        ndeltx = -1;
      else
        ndeltx = ((
            int)((((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) > 0.0
                     ? (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) + 0.5
                     : (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) -
                           0.5));
      for (j = 0; j < ndeltx && np < nx; j++) {
        interface[np++] = zprev + (j * dx * deltz) / deltx;
      }
      xprev = x[i];
      zprev = z[i];
    }
    for (j = np; j < *pmaxx; j++)
      interface[j] = z[nxp - 1];
  } else if (poly == 1) {
    xa = (float *)malloc((nxp + 1) * sizeof(float));
    za = (float *)malloc((nxp + 1) * sizeof(float));
    for (i = 1; i <= nxp; i++)
      xa[i] = x[i - 1];
    for (i = 1; i <= nxp; i++)
      za[i] = z[i - 1];
    np = 0;
    minx = nx * dx;
    maxx = 0;
    for (i = 0; i < nxp; i++) {
      if (x[i] < minx) {
        xprev = x[i];
        minx = x[i];
        *pminx =
            ((int)((minx / dx) > 0.0 ? (minx / dx) + 0.5 : (minx / dx) - 0.5));
        np = *pminx;
      }
      if (x[i] > maxx) {
        maxx = x[i];
        *pmaxx =
            ((((int)(((maxx + dx) / dx) > 0.0 ? ((maxx + dx) / dx) + 0.5
                                              : ((maxx + dx) / dx) - 0.5))) <
                     (nx)
                 ? (((int)(((maxx + dx) / dx) > 0.0
                               ? ((maxx + dx) / dx) + 0.5
                               : ((maxx + dx) / dx) - 0.5)))
                 : (nx));
      }
    }
    for (j = *pminx; j < *pmaxx; j++) {
      xp = j * dx;
      polint(xa, za, nxp, xp, &interface[j], &dyp);
    }
    free(xa);
    free(za);
  } else if (poly == 2) {
    xa = (float *)malloc((nxp + 1) * sizeof(float));
    za = (float *)malloc((nxp + 1) * sizeof(float));
    for (i = 1; i <= nxp; i++)
      xa[i] = x[i - 1];
    for (i = 1; i <= nxp; i++)
      za[i] = z[i - 1];
    np = 0;
    minx = nx * dx;
    maxx = 0;
    for (i = 0; i < nxp; i++) {
      if (x[i] < minx) {
        xprev = x[i];
        minx = x[i];
        *pminx =
            ((int)((minx / dx) > 0.0 ? (minx / dx) + 0.5 : (minx / dx) - 0.5));
        np = *pminx;
      }
      if (x[i] > maxx) {
        maxx = x[i];
        *pmaxx =
            ((((int)(((maxx + dx) / dx) > 0.0 ? ((maxx + dx) / dx) + 0.5
                                              : ((maxx + dx) / dx) - 0.5))) <
                     (nx)
                 ? (((int)(((maxx + dx) / dx) > 0.0
                               ? ((maxx + dx) / dx) + 0.5
                               : ((maxx + dx) / dx) - 0.5)))
                 : (nx));
      }
    }
    y2 = (float *)malloc((nxp + 1) * sizeof(float));
    yp1 = ypn = 1e30;
    spline(xa, za, nxp, yp1, ypn, y2);
    for (j = *pminx; j < *pmaxx; j++) {
      xp = j * dx;
      splint(xa, za, y2, nxp, xp, &interface[j]);
    }
    free(y2);
    free(xa);
    free(za);
  }
  if (nvel != 1) {
    if (nvel != 2) {
      for (j = 0; j < nx; j++) {
        cp[0][j] = cp[1][j];
        cs[0][j] = cs[1][j];
        ro[0][j] = ro[1][j];
      }
      np = 0;
      xprev = cpprev = csprev = roprev = 0.0;
      minx = nx * dx;
      maxx = 0;
      for (i = 0; i < nxp; i++) {
        if (x[i] < minx) {
          xprev = x[i];
          minx = x[i];
          *pminx = ((int)((minx / dx) > 0.0 ? (minx / dx) + 0.5
                                            : (minx / dx) - 0.5));
          np = *pminx;
        }
        if (x[i] > maxx) {
          maxx = x[i];
          *pmaxx =
              ((((int)(((maxx + dx) / dx) > 0.0 ? ((maxx + dx) / dx) + 0.5
                                                : ((maxx + dx) / dx) - 0.5))) <
                       (nx)
                   ? (((int)(((maxx + dx) / dx) > 0.0
                                 ? ((maxx + dx) / dx) + 0.5
                                 : ((maxx + dx) / dx) - 0.5)))
                   : (nx));
        }
        deltx = x[i] - xprev;
        deltcp = cp[2][i] - cpprev;
        deltcs = cs[2][i] - csprev;
        deltro = ro[2][i] - roprev;
        if (i == 0)
          ndeltx = -1;
        else
          ndeltx =
              ((int)((((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) > 0.0
                         ? (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) +
                               0.5
                         : (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) -
                               0.5)) -
              1;
        if (ndeltx == 0)
          ndeltx = 1;
        for (j = 0; j <= ndeltx; j++) {
          cp[1][np] = cpprev + (j * dx * deltcp) / deltx;
          cs[1][np] = csprev + (j * dx * deltcs) / deltx;
          ro[1][np] = roprev + (j * dx * deltro) / deltx;
          np += 1;
        }
        xprev = x[i];
        cpprev = cp[2][i];
        csprev = cs[2][i];
        roprev = ro[2][i];
      }
      cp[1][np] = cpprev;
      cs[1][np] = csprev;
      ro[1][np] = roprev;
    } else {
      for (j = 0; j < nx; j++) {
        cp[0][j] = cp[1][j];
        cs[0][j] = cs[1][j];
        ro[0][j] = ro[1][j];
      }
      np = 0;
      xprev = 0.0;
      minx = nx * dx;
      maxx = 0;
      cpprev = cp[2][0];
      csprev = cs[2][0];
      roprev = ro[2][0];
      deltcp = cp[2][1] - cpprev;
      deltcs = cs[2][1] - csprev;
      deltro = ro[2][1] - roprev;
      minx = x[0];
      maxx = x[nxp - 1];
      deltx = maxx - minx;
      np = ((int)((minx / dx) > 0.0 ? (minx / dx) + 0.5 : (minx / dx) - 0.5));
      ndeltx =
          ((int)((((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) > 0.0
                     ? (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) + 0.5
                     : (((deltx / dx) < 0 ? -(deltx / dx) : (deltx / dx))) -
                           0.5));
      for (j = 0; j <= ndeltx; j++) {
        cp[1][np] = cpprev + (j * dx * deltcp) / deltx;
        cs[1][np] = csprev + (j * dx * deltcs) / deltx;
        ro[1][np] = roprev + (j * dx * deltro) / deltx;
        np += 1;
      }
    }
  } else {
    for (j = 0; j < nx; j++) {
      cp[0][j] = cp[1][j];
      cs[0][j] = cs[1][j];
      ro[0][j] = ro[1][j];
      cp[1][j] = cp[2][0];
      cs[1][j] = cs[2][0];
      ro[1][j] = ro[2][0];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<interpolation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    1673 <interpolation+0x523>
movl   $0x0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    162c <interpolation+0x4dc>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1296 <interpolation+0x146>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1259 <interpolation+0x109>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1dc0(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    127b <interpolation+0x12b>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d99(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    13e6 <interpolation+0x296>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    130b <interpolation+0x1bb>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d0e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1332 <interpolation+0x1e2>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1ce2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
cmp    -0x18(%rbp),%eax
jge    13d1 <interpolation+0x281>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1393 <interpolation+0x243>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c86(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    13ba <interpolation+0x26a>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c5a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xb4(%rbp)
jmp    13da <interpolation+0x28a>
mov    -0x18(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
cmpl   $0x0,-0x30(%rbp)
jne    142a <interpolation+0x2da>
movl   $0xffffffff,-0x38(%rbp)
jmp    157b <interpolation+0x42b>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    1464 <interpolation+0x314>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
jmp    1476 <interpolation+0x326>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1500 <interpolation+0x3b0>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    14c9 <interpolation+0x379>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
jmp    14db <interpolation+0x38b>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1b19(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    156c <interpolation+0x41c>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    153a <interpolation+0x3ea>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
jmp    154c <interpolation+0x3fc>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1aa8(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0x38(%rbp),%ecx
mov    %al,-0xcd(%rbp)
jge    15a5 <interpolation+0x455>
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
setl   %al
mov    %al,-0xcd(%rbp)
mov    -0xcd(%rbp),%al
test   $0x1,%al
jne    15b8 <interpolation+0x468>
jmp    15fa <interpolation+0x4aa>
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1582 <interpolation+0x432>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11cc <interpolation+0x7c>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    166e <interpolation+0x51e>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x38(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1632 <interpolation+0x4e2>
jmp    1df3 <interpolation+0xca3>
cmpl   $0x1,-0x1c(%rbp)
jne    19fa <interpolation+0x8aa>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16eb <interpolation+0x59b>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16b2 <interpolation+0x562>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     172b <interpolation+0x5db>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16f2 <interpolation+0x5a2>
movl   $0x0,-0x3c(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    197d <interpolation+0x82d>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    181a <interpolation+0x6ca>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17dd <interpolation+0x68d>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x183c(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    17ff <interpolation+0x6af>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1815(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    196a <interpolation+0x81a>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    188f <interpolation+0x73f>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x178a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    18b6 <interpolation+0x766>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x175e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
cmp    -0x18(%rbp),%eax
jge    1955 <interpolation+0x805>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1917 <interpolation+0x7c7>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1702(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    193e <interpolation+0x7ee>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16d6(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xec(%rbp)
jmp    195e <interpolation+0x80e>
mov    -0x18(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xec(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    196f <interpolation+0x81f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1750 <interpolation+0x600>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    19e3 <interpolation+0x893>
cvtsi2ssl -0x34(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x14(%rbp),%edx
movss  -0x88(%rbp),%xmm0
ff
mov    0x38(%rbp),%rcx
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
lea    -0x84(%rbp),%r8
call   1060 <polint@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1986 <interpolation+0x836>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
jmp    1dee <interpolation+0xc9e>
cmpl   $0x2,-0x1c(%rbp)
jne    1de9 <interpolation+0xc99>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1a72 <interpolation+0x922>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a39 <interpolation+0x8e9>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1ab2 <interpolation+0x962>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a79 <interpolation+0x929>
movl   $0x0,-0x3c(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d04 <interpolation+0xbb4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1ba1 <interpolation+0xa51>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b64 <interpolation+0xa14>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x14b5(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
jmp    1b86 <interpolation+0xa36>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x148e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    1cf1 <interpolation+0xba1>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c16 <interpolation+0xac6>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1403(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1c3d <interpolation+0xaed>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13d7(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
cmp    -0x18(%rbp),%eax
jge    1cdc <interpolation+0xb8c>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c9e <interpolation+0xb4e>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x137b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1cc5 <interpolation+0xb75>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x134f(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x10c(%rbp)
jmp    1ce5 <interpolation+0xb95>
mov    -0x18(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
jmp    1cf6 <interpolation+0xba6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ad7 <interpolation+0x987>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x98(%rbp)
movss  0x12da(%rip),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  0x12ca(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x14(%rbp),%edx
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm1
ff
mov    -0x98(%rbp),%rcx
call   1070 <spline@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1dcb <interpolation+0xc7b>
cvtsi2ssl -0x34(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x98(%rbp),%rdx
mov    -0x14(%rbp),%ecx
movss  -0x88(%rbp),%xmm0
ff
mov    0x38(%rbp),%r8
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r8
call   1040 <splint@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d6e <interpolation+0xc1e>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
jmp    1dee <interpolation+0xc9e>
jmp    1df3 <interpolation+0xca3>
cmpl   $0x1,0x30(%rbp)
je     2801 <interpolation+0x16b1>
cmpl   $0x2,0x30(%rbp)
je     242a <interpolation+0x12da>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1e8b <interpolation+0xd3b>
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e0e <interpolation+0xcbe>
movl   $0x0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    23e3 <interpolation+0x1293>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1f9a <interpolation+0xe4a>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f5d <interpolation+0xe0d>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10bc(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1f7f <interpolation+0xe2f>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1095(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    20ea <interpolation+0xf9a>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    200f <interpolation+0xebf>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x100a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
jmp    2036 <interpolation+0xee6>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xfde(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
cmp    -0x18(%rbp),%eax
jge    20d5 <interpolation+0xf85>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2097 <interpolation+0xf47>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf82(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    20be <interpolation+0xf6e>
movss  -0x54(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf56(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x12c(%rbp)
jmp    20de <interpolation+0xf8e>
mov    -0x18(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x30(%rbp)
jne    2168 <interpolation+0x1018>
movl   $0xffffffff,-0x38(%rbp)
jmp    22bc <interpolation+0x116c>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    21a2 <interpolation+0x1052>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
jmp    21b4 <interpolation+0x1064>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    223e <interpolation+0x10ee>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    2207 <interpolation+0x10b7>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
jmp    2219 <interpolation+0x10c9>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xddb(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    22aa <interpolation+0x115a>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    2278 <interpolation+0x1128>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
jmp    228a <interpolation+0x113a>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xd6a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    22cd <interpolation+0x117d>
movl   $0x1,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     2381 <interpolation+0x1231>
movss  -0x64(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    22d4 <interpolation+0x1184>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ed0 <interpolation+0xd80>
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    27fc <interpolation+0x16ac>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    24ae <interpolation+0x135e>
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2431 <interpolation+0x12e1>
movl   $0x0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movss  0x4(%rax),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movss  0x4(%rax),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  0x4(%rax),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    25c1 <interpolation+0x1471>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa58(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    25e3 <interpolation+0x1493>
movss  -0x50(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa31(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    262c <interpolation+0x14dc>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
jmp    263e <interpolation+0x14ee>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  -0x154(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    26c8 <interpolation+0x1578>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    2691 <interpolation+0x1541>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x158(%rbp)
ff
jmp    26a3 <interpolation+0x1553>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movss  -0x158(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x951(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    2734 <interpolation+0x15e4>
movss  -0x40(%rbp),%xmm1
divss  -0x2c(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm1,%xmm0
jbe    2702 <interpolation+0x15b2>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x164(%rbp)
ff
jmp    2714 <interpolation+0x15c4>
movss  -0x40(%rbp),%xmm0
divss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x164(%rbp)
ff
movss  -0x164(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x8e0(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     27f7 <interpolation+0x16a7>
movss  -0x64(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x58(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
cvtsi2ssl -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
divss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    274a <interpolation+0x15fa>
jmp    27fc <interpolation+0x16ac>
jmp    28e1 <interpolation+0x1791>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    28dc <interpolation+0x178c>
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
mov    0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm0
mov    0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2808 <interpolation+0x16b8>
jmp    28e1 <interpolation+0x1791>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpolation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x40(%rsp)
mov    %ecx,%ebp
mov    %rsi,%r13
mov    %rdi,%r15
mov    0x118(%rsp),%r9
mov    0x110(%rsp),%ecx
mov    0xf0(%rsp),%r12
cmp    $0x2,%r8d
movaps %xmm0,0x10(%rsp)
mov    %ebp,0xc(%rsp)
je     147f <interpolation+0x32f>
cmp    $0x1,%r8d
je     1510 <interpolation+0x3c0>
movaps %xmm0,%xmm7
test   %r8d,%r8d
jne    1f59 <interpolation+0xe09>
test   %edx,%edx
mov    %rdx,0x30(%rsp)
jle    15a7 <interpolation+0x457>
cvtsi2ss %ebp,%xmm13
mulss  %xmm7,%xmm13
movslq %ebp,%rcx
mov    %edx,%r14d
movaps %xmm7,%xmm15
shufps $0x0,%xmm7,%xmm15
lea    0x10(%r9),%rax
mov    %rax,0x80(%rsp)
xor    %edi,%edi
xorps  %xmm10,%xmm10
lea    0x1e13(%rip),%r11
movaps 0x1e1b(%rip),%xmm9
mov    $0x1,%r10d
movaps 0x1e1d(%rip),%xmm8
movdqa 0x1e24(%rip),%xmm11
movdqa 0x1e2b(%rip),%xmm12
xorps  %xmm14,%xmm14
xorps  %xmm6,%xmm6
xorps  %xmm1,%xmm1
xor    %eax,%eax
mov    %r15,%r8
jmp    1245 <interpolation+0xf5>
cs nopw 0x0(%rax,%rax,1)
movaps 0x10(%rsp),%xmm7
add    $0x1,%rdi
movaps %xmm3,%xmm6
cmp    %r14,%rdi
je     15a9 <interpolation+0x459>
movaps %xmm1,%xmm2
movss  (%r8,%rdi,4),%xmm1
ucomiss %xmm1,%xmm13
jbe    1280 <interpolation+0x130>
movaps %xmm1,%xmm2
divss  %xmm7,%xmm2
xor    %eax,%eax
ucomiss %xmm10,%xmm2
seta   %al
cvtss2sd %xmm2,%xmm2
addsd  (%r11,%rax,8),%xmm2
cvttsd2si %xmm2,%eax
mov    0x40(%rsp),%rdx
mov    %eax,(%rdx)
movaps %xmm1,%xmm2
movaps %xmm1,%xmm13
ucomiss %xmm14,%xmm1
jbe    12b5 <interpolation+0x165>
movaps %xmm1,%xmm3
addss  %xmm7,%xmm3
divss  %xmm7,%xmm3
xor    %edx,%edx
ucomiss %xmm10,%xmm3
seta   %dl
cvtss2sd %xmm3,%xmm3
addsd  (%r11,%rdx,8),%xmm3
cvttsd2si %xmm3,%edx
cmp    %ebp,%edx
cmovge %ebp,%edx
mov    %edx,(%r12)
movaps %xmm1,%xmm14
movss  0x0(%r13,%rdi,4),%xmm3
test   %rdi,%rdi
je     1235 <interpolation+0xe5>
movaps %xmm1,%xmm5
subss  %xmm2,%xmm5
movaps %xmm5,%xmm2
divss  %xmm7,%xmm2
movaps %xmm2,%xmm4
xorps  %xmm9,%xmm4
movaps %xmm2,%xmm7
cmpltss %xmm10,%xmm7
andps  %xmm7,%xmm4
andnps %xmm2,%xmm7
orps   %xmm4,%xmm7
xor    %edx,%edx
ucomiss %xmm10,%xmm7
seta   %dl
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
addsd  (%r11,%rdx,8),%xmm2
cvttsd2si %xmm2,%esi
test   %esi,%esi
jle    1230 <interpolation+0xe0>
cmp    %ebp,%eax
jge    1230 <interpolation+0xe0>
subss  %xmm6,%xmm3
cltq
lea    -0x1(%rsi),%edx
mov    %rax,%rbp
not    %rbp
add    %rcx,%rbp
cmp    %rdx,%rbp
cmovae %rdx,%rbp
add    $0x1,%rbp
test   %edx,%edx
cmove  %r10,%rbp
xor    %ebx,%ebx
cmp    $0x4,%rbp
movaps 0x10(%rsp),%xmm7
jae    134f <interpolation+0x1ff>
mov    0xc(%rsp),%ebp
jmp    1440 <interpolation+0x2f0>
mov    %rbp,%rbx
movabs $0x1fffffffc,%rdx
and    %rdx,%rbx
movaps %xmm3,%xmm1
shufps $0x0,%xmm3,%xmm1
movaps %xmm5,%xmm4
shufps $0x0,%xmm5,%xmm4
movaps %xmm6,%xmm2
shufps $0x0,%xmm6,%xmm2
lea    -0x4(%rbx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     13f4 <interpolation+0x2a4>
mov    %r8,%r12
and    $0xfffffffffffffffe,%r12
mov    0x80(%rsp),%rdx
lea    (%rdx,%rax,4),%r9
xor    %edx,%edx
movaps %xmm8,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtdq2ps %xmm7,%xmm0
mulps  %xmm15,%xmm0
mulps  %xmm1,%xmm0
divps  %xmm4,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,-0x10(%r9,%rdx,4)
movaps %xmm7,%xmm0
paddd  %xmm11,%xmm0
cvtdq2ps %xmm0,%xmm0
mulps  %xmm15,%xmm0
mulps  %xmm1,%xmm0
divps  %xmm4,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,(%r9,%rdx,4)
add    $0x8,%rdx
paddd  %xmm12,%xmm7
add    $0xfffffffffffffffe,%r12
jne    13b0 <interpolation+0x260>
jmp    13fa <interpolation+0x2aa>
xor    %edx,%edx
movaps %xmm8,%xmm7
test   $0x1,%r8b
mov    0x118(%rsp),%r9
je     1420 <interpolation+0x2d0>
add    %rax,%rdx
cvtdq2ps %xmm7,%xmm0
mulps  %xmm15,%xmm0
mulps  %xmm0,%xmm1
divps  %xmm4,%xmm1
addps  %xmm1,%xmm2
movups %xmm2,(%r9,%rdx,4)
add    %rbx,%rax
cmp    %rbx,%rbp
movaps 0x10(%rsp),%xmm7
mov    0xc(%rsp),%ebp
mov    0xf0(%rsp),%r12
mov    %r15,%r8
je     146d <interpolation+0x31d>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  %xmm7,%xmm0
mulss  %xmm3,%xmm0
divss  %xmm5,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rax
add    $0x1,%ebx
cmp    %esi,%ebx
jge    146d <interpolation+0x31d>
cmp    %rcx,%rax
jl     1440 <interpolation+0x2f0>
movss  (%r8,%rdi,4),%xmm1
movss  0x0(%r13,%rdi,4),%xmm3
jmp    1235 <interpolation+0xe5>
lea    0x4(,%rdx,4),%r12d
mov    %r12d,%edi
mov    %rdx,%rbx
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rbx,%r10
movaps 0x10(%rsp),%xmm4
test   %r10d,%r10d
mov    %r15,%rbx
jle    1c24 <interpolation+0xad4>
mov    %r10d,%r9d
lea    0x1(%r9),%rcx
mov    $0x1,%edx
cmp    $0x8,%r10d
jb     1737 <interpolation+0x5e7>
lea    0x4(%r14),%rsi
lea    (%rbx,%rcx,4),%rdi
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rsi
jae    14e5 <interpolation+0x395>
lea    (%r14,%rcx,4),%rsi
cmp    %rbx,%rsi
ja     1737 <interpolation+0x5e7>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1683 <interpolation+0x533>
xor    %edi,%edi
jmp    16f1 <interpolation+0x5a1>
lea    0x4(,%rdx,4),%ebx
mov    %ebx,%edi
mov    %rdx,%r14
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    0x118(%rsp),%r9
movaps 0x10(%rsp),%xmm4
mov    %rax,%r10
test   %r14d,%r14d
mov    %r15,%rax
jle    1ec4 <interpolation+0xd74>
mov    %r14d,%r11d
lea    0x1(%r11),%rcx
mov    $0x1,%edx
cmp    $0x8,%r14d
jb     18c3 <interpolation+0x773>
lea    0x4(%r12),%rsi
lea    (%rax,%rcx,4),%rdi
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rsi
jae    157c <interpolation+0x42c>
lea    (%r12,%rcx,4),%rsi
cmp    %rax,%rsi
ja     18c3 <interpolation+0x773>
mov    %r11d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdi
jae    1814 <interpolation+0x6c4>
xor    %edi,%edi
jmp    1881 <interpolation+0x731>
xor    %eax,%eax
movslq (%r12),%r11
cmp    %r11d,%eax
mov    0x30(%rsp),%rdx
mov    0x110(%rsp),%ecx
jge    1f59 <interpolation+0xe09>
movslq %edx,%rdi
lea    -0x4(,%rdi,4),%rsi
ff
add    %r13,%rsi
cltq
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jb     19da <interpolation+0x88a>
add    $0xffffffffffffffff,%rdi
lea    (%r9,%rax,4),%rbp
lea    0x4(,%rdi,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rbp
jae    160c <interpolation+0x4bc>
lea    (%r9,%r11,4),%rdi
cmp    %rdi,%rsi
jae    160c <interpolation+0x4bc>
mov    0xc(%rsp),%ebp
jmp    19da <interpolation+0x88a>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdi
mov    %rdi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     19a4 <interpolation+0x854>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %r9,%rdi
movss  (%rsi),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x118(%rsp),%rbx
lea    (%rbx,%rax,4),%rbp
add    $0x30,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,-0x30(%rbp,%rbx,4)
movups %xmm0,-0x20(%rbp,%rbx,4)
movups %xmm0,-0x10(%rbp,%rbx,4)
movups %xmm0,0x0(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1660 <interpolation+0x510>
jmp    19a6 <interpolation+0x856>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,0x4(%r14,%rdi,4)
movups %xmm1,0x14(%r14,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x24(%r14,%rdi,4)
movups %xmm1,0x34(%r14,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x44(%r14,%rdi,4)
movups %xmm1,0x54(%r14,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x64(%r14,%rdi,4)
movups %xmm1,0x74(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1690 <interpolation+0x540>
test   %rbp,%rbp
je     172a <interpolation+0x5da>
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
or     $0x4,%rsi
movups %xmm0,(%r14,%rsi,1)
movups %xmm1,0x10(%r14,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    1700 <interpolation+0x5b0>
cmp    %rdx,%r9
mov    0xc(%rsp),%ebp
je     17ab <interpolation+0x65b>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     1766 <interpolation+0x616>
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,(%r14,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1750 <interpolation+0x600>
cmp    $0x3,%rsi
jb     17ab <interpolation+0x65b>
nopl   0x0(%rax)
movss  -0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,(%r14,%rdx,4)
movss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0x4(%r14,%rdx,4)
movss  0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x8(%r14,%rdx,4)
movss  0x8(%rbx,%rdx,4),%xmm0
movss  %xmm0,0xc(%r14,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1770 <interpolation+0x620>
test   %r10d,%r10d
jle    1c24 <interpolation+0xad4>
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     1aff <interpolation+0x9af>
lea    0x4(%rax),%rsi
lea    -0x4(,%rcx,4),%rdi
ff
add    %r13,%rdi
cmp    %rdi,%rsi
jae    17e8 <interpolation+0x698>
lea    (%rax,%rcx,4),%rsi
cmp    %r13,%rsi
ja     1aff <interpolation+0x9af>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rbp
jae    1a49 <interpolation+0x8f9>
xor    %ebp,%ebp
jmp    1ab2 <interpolation+0x962>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,0x4(%r12,%rdi,4)
movups %xmm1,0x14(%r12,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x24(%r12,%rdi,4)
movups %xmm1,0x34(%r12,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x44(%r12,%rdi,4)
movups %xmm1,0x54(%r12,%rdi,4)
movups 0x60(%rax,%rdi,4),%xmm0
movups 0x70(%rax,%rdi,4),%xmm1
movups %xmm0,0x64(%r12,%rdi,4)
movups %xmm1,0x74(%r12,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1820 <interpolation+0x6d0>
test   %rbx,%rbx
je     18ba <interpolation+0x76a>
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
or     $0x4,%rsi
movups %xmm0,(%r12,%rsi,1)
movups %xmm1,0x10(%r12,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbx
jne    1890 <interpolation+0x740>
cmp    %rdx,%r11
je     193b <interpolation+0x7eb>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     18f6 <interpolation+0x7a6>
cs nopw 0x0(%rax,%rax,1)
movss  -0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    18e0 <interpolation+0x790>
cmp    $0x3,%rsi
jb     193b <interpolation+0x7eb>
nopl   0x0(%rax)
movss  -0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,0x4(%r12,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,0x8(%r12,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
movss  %xmm0,0xc(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1900 <interpolation+0x7b0>
test   %r14d,%r14d
jle    1ec4 <interpolation+0xd74>
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     1da9 <interpolation+0xc59>
lea    0x4(%r10),%rsi
lea    -0x4(,%rcx,4),%rdi
ff
add    %r13,%rdi
cmp    %rdi,%rsi
jae    1978 <interpolation+0x828>
lea    (%r10,%rcx,4),%rsi
cmp    %r13,%rsi
ja     1da9 <interpolation+0xc59>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rbp
jae    1ce6 <interpolation+0xb96>
xor    %ebx,%ebx
jmp    1d5a <interpolation+0xc0a>
xor    %ebx,%ebx
test   $0x1,%r9b
mov    0x118(%rsp),%r9
je     19ca <interpolation+0x87a>
add    %rax,%rbx
movss  (%rsi),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,(%r9,%rbx,4)
movups %xmm0,0x10(%r9,%rbx,4)
cmp    %r8,%r10
mov    0xc(%rsp),%ebp
je     1f59 <interpolation+0xe09>
add    %r8,%rax
mov    %r11d,%edi
sub    %eax,%edi
mov    %rax,%rbx
not    %rbx
add    %r11,%rbx
and    $0x3,%rdi
je     1a04 <interpolation+0x8b4>
xchg   %ax,%ax
movss  (%rsi),%xmm0
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    19f0 <interpolation+0x8a0>
cmp    $0x3,%rbx
jb     1f59 <interpolation+0xe09>
xchg   %ax,%ax
movss  (%rsi),%xmm0
movss  %xmm0,(%r9,%rax,4)
movss  (%rsi),%xmm0
movss  %xmm0,0x4(%r9,%rax,4)
movss  (%rsi),%xmm0
movss  %xmm0,0x8(%r9,%rax,4)
movss  (%rsi),%xmm0
movss  %xmm0,0xc(%r9,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1a10 <interpolation+0x8c0>
jmp    1f59 <interpolation+0xe09>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nop
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
movups %xmm0,0x4(%rax,%rbp,4)
movups %xmm1,0x14(%rax,%rbp,4)
movups 0x20(%r13,%rbp,4),%xmm0
movups 0x30(%r13,%rbp,4),%xmm1
movups %xmm0,0x24(%rax,%rbp,4)
movups %xmm1,0x34(%rax,%rbp,4)
movups 0x40(%r13,%rbp,4),%xmm0
movups 0x50(%r13,%rbp,4),%xmm1
movups %xmm0,0x44(%rax,%rbp,4)
movups %xmm1,0x54(%rax,%rbp,4)
movups 0x60(%r13,%rbp,4),%xmm0
movups 0x70(%r13,%rbp,4),%xmm1
movups %xmm0,0x64(%rax,%rbp,4)
movups %xmm1,0x74(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1a50 <interpolation+0x900>
test   %rsi,%rsi
je     1aeb <interpolation+0x99b>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rbp,4),%rdi
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
or     $0x4,%rdi
movups %xmm0,(%rax,%rdi,1)
movups %xmm1,0x10(%rax,%rdi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rsi
jne    1ac0 <interpolation+0x970>
cmp    %rdx,%r8
mov    0xc(%rsp),%ebp
mov    %r15,%rbx
je     1b7c <interpolation+0xa2c>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %r15,%rbx
and    $0x3,%rdi
je     1b36 <interpolation+0x9e6>
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1b20 <interpolation+0x9d0>
cmp    $0x3,%rsi
jb     1b7c <interpolation+0xa2c>
nopl   0x0(%rax)
movss  -0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
movss  0x8(%r13,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1b40 <interpolation+0x9f0>
test   %r10d,%r10d
jle    1c24 <interpolation+0xad4>
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
mulss  %xmm4,%xmm1
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
lea    0x1464(%rip),%rdx
xorps  %xmm3,%xmm3
jmp    1bb9 <interpolation+0xa69>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%r9
je     1c24 <interpolation+0xad4>
movss  (%rbx,%rcx,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    1bea <interpolation+0xa9a>
movaps %xmm2,%xmm1
divss  %xmm4,%xmm1
xor    %esi,%esi
ucomiss %xmm0,%xmm1
seta   %sil
cvtss2sd %xmm1,%xmm1
addsd  (%rdx,%rsi,8),%xmm1
cvttsd2si %xmm1,%esi
mov    0x40(%rsp),%rdi
mov    %esi,(%rdi)
movaps %xmm2,%xmm1
ucomiss %xmm3,%xmm2
jbe    1bb0 <interpolation+0xa60>
movaps %xmm2,%xmm3
addss  %xmm4,%xmm3
divss  %xmm4,%xmm3
xor    %esi,%esi
ucomiss %xmm0,%xmm3
seta   %sil
cvtss2sd %xmm3,%xmm3
addsd  (%rdx,%rsi,8),%xmm3
cvttsd2si %xmm3,%esi
cmp    %ebp,%esi
cmovge %ebp,%esi
mov    0xf0(%rsp),%rdi
mov    %esi,(%rdi)
movaps %xmm2,%xmm3
jmp    1bb0 <interpolation+0xa60>
mov    %rbx,0x20(%rsp)
mov    %r12d,%edi
mov    %r10,%rbx
mov    %rax,%r12
call   1050 <malloc@plt>
mov    %rax,%r13
movss  0x140e(%rip),%xmm0
mov    %r14,%rdi
mov    %r12,%rsi
mov    %rbx,0x30(%rsp)
mov    %ebx,%edx
movaps %xmm0,%xmm1
mov    %rax,%rcx
call   1070 <spline@plt>
mov    0x40(%rsp),%rax
movslq (%rax),%rbx
mov    0xf0(%rsp),%r15
cmp    (%r15),%ebx
jge    1cb3 <interpolation+0xb63>
mov    0x118(%rsp),%rax
lea    (%rax,%rbx,4),%rbp
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0x10(%rsp),%xmm0
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
mov    0x30(%rsp),%rcx
mov    %rbp,%r8
call   1040 <splint@plt>
add    $0x1,%rbx
movslq (%r15),%rax
add    $0x4,%rbp
cmp    %rax,%rbx
jl     1c80 <interpolation+0xb30>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
movaps 0x10(%rsp),%xmm7
mov    0xc(%rsp),%ebp
mov    %r15,%r12
mov    0x20(%rsp),%r15
mov    0x30(%rsp),%rdx
jmp    1f52 <interpolation+0xe02>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movups 0x0(%r13,%rbx,4),%xmm0
movups 0x10(%r13,%rbx,4),%xmm1
movups %xmm0,0x4(%r10,%rbx,4)
movups %xmm1,0x14(%r10,%rbx,4)
movups 0x20(%r13,%rbx,4),%xmm0
movups 0x30(%r13,%rbx,4),%xmm1
movups %xmm0,0x24(%r10,%rbx,4)
movups %xmm1,0x34(%r10,%rbx,4)
movups 0x40(%r13,%rbx,4),%xmm0
movups 0x50(%r13,%rbx,4),%xmm1
movups %xmm0,0x44(%r10,%rbx,4)
movups %xmm1,0x54(%r10,%rbx,4)
movups 0x60(%r13,%rbx,4),%xmm0
movups 0x70(%r13,%rbx,4),%xmm1
movups %xmm0,0x64(%r10,%rbx,4)
movups %xmm1,0x74(%r10,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1cf0 <interpolation+0xba0>
test   %rsi,%rsi
mov    0xc(%rsp),%ebp
je     1d9d <interpolation+0xc4d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rbx,4),%rdi
movups 0x0(%r13,%rbx,4),%xmm0
movups 0x10(%r13,%rbx,4),%xmm1
or     $0x4,%rdi
movups %xmm0,(%r10,%rdi,1)
movups %xmm1,0x10(%r10,%rdi,1)
add    $0x8,%rbx
add    $0xffffffffffffffff,%rsi
jne    1d70 <interpolation+0xc20>
cmp    %rdx,%r8
mov    %r15,%rax
je     1e20 <interpolation+0xcd0>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %r15,%rax
and    $0x3,%rdi
je     1dd7 <interpolation+0xc87>
nop
movss  -0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,(%r10,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1dc0 <interpolation+0xc70>
cmp    $0x3,%rsi
jb     1e20 <interpolation+0xcd0>
nopl   (%rax)
movss  -0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,(%r10,%rdx,4)
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,0x4(%r10,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,0x8(%r10,%rdx,4)
movss  0x8(%r13,%rdx,4),%xmm0
movss  %xmm0,0xc(%r10,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1de0 <interpolation+0xc90>
test   %r14d,%r14d
jle    1ec4 <interpolation+0xd74>
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
mulss  %xmm4,%xmm1
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
lea    0x11c0(%rip),%rdx
xorps  %xmm3,%xmm3
jmp    1e59 <interpolation+0xd09>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
cmp    %rcx,%r11
je     1ec4 <interpolation+0xd74>
movss  (%rax,%rcx,4),%xmm2
ucomiss %xmm2,%xmm1
jbe    1e8a <interpolation+0xd3a>
movaps %xmm2,%xmm1
divss  %xmm4,%xmm1
xor    %esi,%esi
ucomiss %xmm0,%xmm1
seta   %sil
cvtss2sd %xmm1,%xmm1
addsd  (%rdx,%rsi,8),%xmm1
cvttsd2si %xmm1,%esi
mov    0x40(%rsp),%rdi
mov    %esi,(%rdi)
movaps %xmm2,%xmm1
ucomiss %xmm3,%xmm2
jbe    1e50 <interpolation+0xd00>
movaps %xmm2,%xmm3
addss  %xmm4,%xmm3
divss  %xmm4,%xmm3
xor    %esi,%esi
ucomiss %xmm0,%xmm3
seta   %sil
cvtss2sd %xmm3,%xmm3
addsd  (%rdx,%rsi,8),%xmm3
cvttsd2si %xmm3,%esi
cmp    %ebp,%esi
cmovge %ebp,%esi
mov    0xf0(%rsp),%rdi
mov    %esi,(%rdi)
movaps %xmm2,%xmm3
jmp    1e50 <interpolation+0xd00>
mov    %rax,0x20(%rsp)
mov    0x40(%rsp),%rax
movslq (%rax),%rbp
mov    0xf0(%rsp),%r15
cmp    (%r15),%ebp
mov    %r10,%r15
jge    1f29 <interpolation+0xdd9>
lea    (%r9,%rbp,4),%rbx
lea    0xb4(%rsp),%r13
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  0x10(%rsp),%xmm0
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
mov    %rbx,%rcx
mov    %r13,%r8
call   1060 <polint@plt>
add    $0x1,%rbp
mov    0xf0(%rsp),%rax
movslq (%rax),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1ef0 <interpolation+0xda0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
movaps 0x10(%rsp),%xmm7
mov    0xc(%rsp),%ebp
mov    0xf0(%rsp),%r12
mov    0x20(%rsp),%r15
mov    %r14,%rdx
mov    0x110(%rsp),%ecx
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r11
cmp    $0x1,%ecx
je     1fb2 <interpolation+0xe62>
cmp    $0x2,%ecx
jne    203d <interpolation+0xeed>
test   %ebp,%ebp
jle    20f4 <interpolation+0xfa4>
mov    (%r11),%rax
mov    0x8(%r11),%rsi
mov    0x0(%r13),%rcx
mov    0x8(%r13),%rdi
mov    (%r14),%r10
mov    %ebp,%ebx
mov    0x8(%r14),%rbp
mov    %ebx,%r8d
cmp    $0x1,%ebx
jne    2072 <interpolation+0xf22>
xor    %ebx,%ebx
jmp    20ce <interpolation+0xf7e>
test   %ebp,%ebp
jle    2941 <interpolation+0x17f1>
mov    (%r11),%r8
mov    0x8(%r11),%rcx
mov    0x0(%r13),%r9
mov    0x8(%r13),%rsi
mov    (%r14),%r10
mov    %ebp,%edi
mov    0x8(%r14),%rbp
mov    0x10(%r11),%r11
mov    0x10(%r13),%rax
mov    0x10(%r14),%rdx
mov    %edi,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%r8,%rbx,4)
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%r9,%rbx,4)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
movss  (%r11),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  (%rax),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  (%rdx),%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1ff0 <interpolation+0xea0>
jmp    2941 <interpolation+0x17f1>
test   %ebp,%ebp
jle    2254 <interpolation+0x1104>
mov    (%r11),%rax
mov    0x8(%r11),%rsi
mov    0x0(%r13),%rcx
mov    0x8(%r13),%rdi
mov    (%r14),%r10
mov    0x8(%r14),%rbp
mov    0xc(%rsp),%ebx
mov    %ebx,%r8d
cmp    $0x1,%ebx
jne    21d7 <interpolation+0x1087>
xor    %ebx,%ebx
jmp    222e <interpolation+0x10de>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
movss  0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,0x4(%rax,%rbx,4)
movss  0x4(%rdi,%rbx,4),%xmm0
movss  %xmm0,0x4(%rcx,%rbx,4)
movss  0x4(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x4(%r10,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    2080 <interpolation+0xf30>
test   $0x1,%r8b
je     20f4 <interpolation+0xfa4>
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
movss  (%r15),%xmm7
movslq %edx,%rax
movss  -0x4(%r15,%rax,4),%xmm0
subss  %xmm7,%xmm0
movaps %xmm0,%xmm1
movaps 0x10(%rsp),%xmm9
divss  %xmm9,%xmm1
movaps 0xef4(%rip),%xmm2
xorps  %xmm1,%xmm2
xorps  %xmm8,%xmm8
movaps %xmm1,%xmm3
cmpltss %xmm8,%xmm3
andps  %xmm3,%xmm2
andnps %xmm1,%xmm3
orps   %xmm2,%xmm3
xor    %eax,%eax
ucomiss %xmm8,%xmm3
seta   %al
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
lea    0xeb4(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm1
cvttsd2si %xmm1,%eax
test   %eax,%eax
js     2941 <interpolation+0x17f1>
mov    0x10(%r11),%rdx
movss  (%rdx),%xmm15
movss  0x4(%rdx),%xmm2
mov    0x10(%r13),%rdx
movss  (%rdx),%xmm12
movss  0x4(%rdx),%xmm4
mov    0x10(%r14),%rdx
movss  (%rdx),%xmm5
movss  0x4(%rdx),%xmm6
subss  %xmm15,%xmm2
subss  %xmm12,%xmm4
divss  %xmm9,%xmm7
xor    %edx,%edx
ucomiss %xmm8,%xmm7
seta   %dl
subss  %xmm5,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm7,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
cvttsd2si %xmm1,%ecx
mov    0x8(%r11),%rdx
mov    0x8(%r13),%rbp
mov    0x8(%r14),%r11
movslq %ecx,%r13
xor    %r14d,%r14d
cmp    $0x3,%eax
jae    273f <interpolation+0x15ef>
movaps 0x10(%rsp),%xmm7
jmp    28c3 <interpolation+0x1773>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ebx,%ebx
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
movss  0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,0x4(%rax,%rbx,4)
movss  0x4(%rdi,%rbx,4),%xmm0
movss  %xmm0,0x4(%rcx,%rbx,4)
movss  0x4(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x4(%r10,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r9
jne    21e0 <interpolation+0x1090>
test   $0x1,%r8b
je     2254 <interpolation+0x1104>
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rbx,4)
test   %edx,%edx
jle    270b <interpolation+0x15bb>
mov    %r15,%rbp
xorps  %xmm13,%xmm13
cvtsi2ssl 0xc(%rsp),%xmm13
mulss  %xmm7,%xmm13
mov    0x10(%r11),%r15
mov    0x10(%r13),%r10
mov    0x10(%r14),%rdi
mov    %edx,%r8d
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
movaps %xmm0,0x30(%rsp)
xor    %eax,%eax
pxor   %xmm11,%xmm11
lea    0xd68(%rip),%rbx
movaps 0xd70(%rip),%xmm12
movdqa 0xd88(%rip),%xmm2
xorps  %xmm3,%xmm3
xorps  %xmm4,%xmm4
xorps  %xmm1,%xmm1
xorps  %xmm14,%xmm14
xorps  %xmm0,%xmm0
xor    %edx,%edx
mov    %rbp,0x20(%rsp)
mov    %r15,0x70(%rsp)
mov    %r10,0x78(%rsp)
mov    %rdi,0xa8(%rsp)
mov    %r8,0xa0(%rsp)
jmp    2328 <interpolation+0x11d8>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  (%r15,%rax,4),%xmm9
movss  (%r10,%rax,4),%xmm10
mov    0xa8(%rsp),%rdi
movss  (%rdi,%rax,4),%xmm8
mov    0xa0(%rsp),%r8
lea    0xcf1(%rip),%rbx
add    $0x1,%rax
movaps %xmm8,%xmm3
movaps %xmm10,%xmm4
movaps %xmm9,%xmm1
cmp    %r8,%rax
je     2719 <interpolation+0x15c9>
movaps %xmm1,0x80(%rsp)
movaps %xmm0,%xmm15
movss  0x0(%rbp,%rax,4),%xmm0
ucomiss %xmm0,%xmm13
jbe    236c <interpolation+0x121c>
movaps %xmm0,%xmm1
divss  %xmm7,%xmm1
xor    %ecx,%ecx
ucomiss %xmm11,%xmm1
seta   %cl
cvtss2sd %xmm1,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
cvttsd2si %xmm1,%edx
mov    0x40(%rsp),%rcx
mov    %edx,(%rcx)
movaps %xmm0,%xmm15
movaps %xmm0,%xmm13
ucomiss %xmm14,%xmm0
jbe    23a4 <interpolation+0x1254>
movaps %xmm0,%xmm1
addss  %xmm7,%xmm1
divss  %xmm7,%xmm1
xor    %ecx,%ecx
ucomiss %xmm11,%xmm1
seta   %cl
cvtss2sd %xmm1,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
cvttsd2si %xmm1,%ecx
mov    0xc(%rsp),%esi
cmp    %esi,%ecx
cmovge %esi,%ecx
mov    %ecx,(%r12)
movaps %xmm0,%xmm14
movss  (%r15,%rax,4),%xmm9
movss  (%r10,%rax,4),%xmm10
movss  (%rdi,%rax,4),%xmm8
test   %rax,%rax
je     230f <interpolation+0x11bf>
movaps %xmm4,0x50(%rsp)
movaps %xmm3,0x60(%rsp)
movaps %xmm0,%xmm4
subss  %xmm15,%xmm4
movaps %xmm4,%xmm1
divss  %xmm7,%xmm1
movaps %xmm1,%xmm3
xorps  %xmm12,%xmm3
movaps %xmm1,%xmm6
cmpltss %xmm11,%xmm6
andps  %xmm6,%xmm3
andnps %xmm1,%xmm6
orps   %xmm3,%xmm6
xor    %ecx,%ecx
ucomiss %xmm11,%xmm6
seta   %cl
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
cvttsd2si %xmm1,%esi
mov    %esi,%ecx
add    $0xffffffff,%ecx
je     2420 <interpolation+0x12d0>
test   %esi,%esi
jg     2425 <interpolation+0x12d5>
jmp    230f <interpolation+0x11bf>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ecx
movaps 0x80(%rsp),%xmm5
subss  %xmm5,%xmm9
movaps 0x50(%rsp),%xmm6
subss  %xmm6,%xmm10
movaps 0x60(%rsp),%xmm3
subss  %xmm3,%xmm8
mov    0x8(%r11),%rsi
mov    0x8(%r13),%rdi
mov    0x8(%r14),%r8
movslq %edx,%rdx
xor    %r9d,%r9d
cmp    $0x3,%ecx
jb     26a0 <interpolation+0x1550>
mov    %ecx,%ebp
lea    (%rsi,%rdx,4),%r11
mov    %rbp,0x98(%rsp)
lea    (%rdx,%rbp,1),%rbx
lea    (%rsi,%rbx,4),%rbp
add    $0x4,%rbp
lea    (%rdi,%rdx,4),%r14
lea    (%rdi,%rbx,4),%r15
add    $0x4,%r15
lea    (%r8,%rdx,4),%r12
lea    (%r8,%rbx,4),%rbx
add    $0x4,%rbx
cmp    %r15,%r11
setb   0x2c(%rsp)
cmp    %rbp,%r14
setb   0x28(%rsp)
cmp    %rbx,%r11
setb   %r10b
cmp    %rbp,%r12
setb   %bpl
cmp    %rbx,%r14
setb   %r13b
cmp    %r15,%r12
setb   %r15b
mov    0x28(%rsp),%bl
test   %bl,0x2c(%rsp)
jne    263b <interpolation+0x14eb>
and    %bpl,%r10b
mov    0x78(%rsp),%r10
jne    266c <interpolation+0x151c>
and    %r15b,%r13b
mov    0x70(%rsp),%r15
jne    2614 <interpolation+0x14c4>
movss  %xmm14,0x28(%rsp)
movss  %xmm13,0x2c(%rsp)
mov    0x98(%rsp),%r10
add    $0x1,%r10
mov    %r10,%r9
movabs $0x1fffffffc,%rbx
and    %rbx,%r9
add    %r9,%rdx
movaps %xmm9,%xmm12
shufps $0x0,%xmm9,%xmm12
movaps %xmm6,%xmm0
movaps %xmm4,%xmm6
shufps $0x0,%xmm4,%xmm6
movaps %xmm5,%xmm1
shufps $0x0,%xmm5,%xmm1
movaps %xmm10,%xmm5
shufps $0x0,%xmm10,%xmm5
shufps $0x0,%xmm0,%xmm0
movaps %xmm8,%xmm7
shufps $0x0,%xmm8,%xmm7
movaps %xmm3,%xmm11
shufps $0x0,%xmm3,%xmm11
xor    %r13d,%r13d
movaps 0xac6(%rip),%xmm13
mov    0x20(%rsp),%rbp
nop
cvtdq2ps %xmm13,%xmm14
mulps  0x30(%rsp),%xmm14
movaps %xmm12,%xmm15
mulps  %xmm14,%xmm15
divps  %xmm6,%xmm15
addps  %xmm1,%xmm15
movups %xmm15,(%r11,%r13,4)
movaps %xmm5,%xmm3
mulps  %xmm14,%xmm3
divps  %xmm6,%xmm3
addps  %xmm0,%xmm3
movups %xmm3,(%r14,%r13,4)
mulps  %xmm7,%xmm14
divps  %xmm6,%xmm14
addps  %xmm11,%xmm14
movups %xmm14,(%r12,%r13,4)
add    $0x4,%r13
paddd  %xmm2,%xmm13
cmp    %r13,%r9
jne    2560 <interpolation+0x1410>
cmp    %r9,%r10
movaps 0x10(%rsp),%xmm7
mov    0xf0(%rsp),%r12
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r11
mov    0x78(%rsp),%r10
xorps  %xmm11,%xmm11
movaps 0xa27(%rip),%xmm12
movss  0x2c(%rsp),%xmm13
movss  0x28(%rsp),%xmm14
movaps 0x60(%rsp),%xmm3
movaps 0x50(%rsp),%xmm6
movaps 0x80(%rsp),%xmm5
je     22e0 <interpolation+0x1190>
jmp    26a0 <interpolation+0x1550>
mov    0x20(%rsp),%rbp
mov    0xf0(%rsp),%r12
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r11
jmp    26a0 <interpolation+0x1550>
mov    0x20(%rsp),%rbp
mov    0xf0(%rsp),%r12
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r11
mov    0x70(%rsp),%r15
mov    0x78(%rsp),%r10
jmp    26a0 <interpolation+0x1550>
mov    0x20(%rsp),%rbp
mov    0xf0(%rsp),%r12
mov    0x108(%rsp),%r14
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r11
mov    0x70(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm9,%xmm1
mulss  %xmm0,%xmm1
divss  %xmm4,%xmm1
addss  %xmm5,%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movaps %xmm10,%xmm1
mulss  %xmm0,%xmm1
divss  %xmm4,%xmm1
addss  %xmm6,%xmm1
movss  %xmm1,(%rdi,%rdx,4)
mulss  %xmm8,%xmm0
divss  %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%r8,%rdx,4)
add    $0x1,%rdx
add    $0x1,%r9d
cmp    %r9d,%ecx
jne    26b0 <interpolation+0x1560>
jmp    22e0 <interpolation+0x1190>
xorps  %xmm9,%xmm9
xor    %edx,%edx
xorps  %xmm10,%xmm10
xorps  %xmm8,%xmm8
mov    0x8(%r11),%rax
movslq %edx,%rcx
movss  %xmm9,(%rax,%rcx,4)
mov    0x8(%r13),%rax
movss  %xmm10,(%rax,%rcx,4)
mov    0x8(%r14),%rax
movss  %xmm8,(%rax,%rcx,4)
jmp    2941 <interpolation+0x17f1>
mov    %eax,%ecx
lea    (%rdx,%r13,4),%rbx
mov    %rcx,0x30(%rsp)
lea    (%rcx,%r13,1),%rsi
mov    %rdx,0x60(%rsp)
lea    0x4(%rdx,%rsi,4),%rdi
lea    0x0(%rbp,%r13,4),%rcx
mov    %rbp,0x50(%rsp)
lea    0x4(%rbp,%rsi,4),%rbp
lea    (%r11,%r13,4),%rdx
lea    (%r11,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rbp,%rbx
setb   %r9b
cmp    %rdi,%rcx
setb   %r10b
cmp    %rsi,%rbx
setb   %r8b
cmp    %rdi,%rdx
setb   %r15b
cmp    %rsi,%rcx
setb   %dil
cmp    %rbp,%rdx
setb   %r12b
test   %r10b,%r9b
jne    28b4 <interpolation+0x1764>
and    %r15b,%r8b
jne    28b4 <interpolation+0x1764>
and    %r12b,%dil
jne    28b4 <interpolation+0x1764>
mov    0x30(%rsp),%rbp
add    $0x1,%rbp
mov    %rbp,%r14
and    $0xfffffffffffffffc,%r14
add    %r14,%r13
movaps 0x10(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0x30(%rsp)
movaps %xmm2,%xmm1
shufps $0x0,%xmm2,%xmm1
movaps %xmm1,0x80(%rsp)
movaps %xmm0,%xmm7
shufps $0x0,%xmm0,%xmm7
movaps %xmm15,%xmm1
shufps $0x0,%xmm15,%xmm1
movaps %xmm1,0x40(%rsp)
movaps %xmm4,%xmm11
shufps $0x0,%xmm4,%xmm11
movaps %xmm12,%xmm10
shufps $0x0,%xmm12,%xmm10
movaps %xmm6,%xmm13
shufps $0x0,%xmm6,%xmm13
movaps %xmm5,%xmm14
shufps $0x0,%xmm5,%xmm14
lea    0x0(,%rbp,4),%rsi
and    $0xfffffffffffffff0,%rsi
movaps 0x7ec(%rip),%xmm1
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
cvtdq2ps %xmm1,%xmm8
mulps  0x30(%rsp),%xmm8
movaps 0x80(%rsp),%xmm9
mulps  %xmm8,%xmm9
divps  %xmm7,%xmm9
addps  0x40(%rsp),%xmm9
movups %xmm9,(%rbx,%rdi,1)
movaps %xmm11,%xmm3
mulps  %xmm8,%xmm3
divps  %xmm7,%xmm3
addps  %xmm10,%xmm3
movups %xmm3,(%rcx,%rdi,1)
mulps  %xmm13,%xmm8
divps  %xmm7,%xmm8
addps  %xmm14,%xmm8
movups %xmm8,(%rdx,%rdi,1)
paddd  0x79e(%rip),%xmm1
add    $0x10,%rdi
cmp    %rdi,%rsi
jne    2840 <interpolation+0x16f0>
cmp    %r14,%rbp
movaps 0x10(%rsp),%xmm7
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rbp
jne    28c3 <interpolation+0x1773>
jmp    2941 <interpolation+0x17f1>
movaps 0x10(%rsp),%xmm7
mov    0x60(%rsp),%rdx
mov    0x50(%rsp),%rbp
lea    (%rdx,%r13,4),%rcx
lea    0x0(,%r13,4),%rdx
add    %rbp,%rdx
lea    (%r11,%r13,4),%rsi
sub    %r14d,%eax
add    $0x1,%eax
mov    %r14d,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbp,1),%ebx
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
mulss  %xmm7,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
divss  %xmm0,%xmm3
addss  %xmm15,%xmm3
movss  %xmm3,(%rcx,%rbp,4)
movaps %xmm4,%xmm3
mulss  %xmm1,%xmm3
divss  %xmm0,%xmm3
addss  %xmm12,%xmm3
movss  %xmm3,(%rdx,%rbp,4)
mulss  %xmm6,%xmm1
divss  %xmm0,%xmm1
addss  %xmm5,%xmm1
movss  %xmm1,(%rsi,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%eax
jne    28f0 <interpolation+0x17a0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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