#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 */
float Extrapolation4(float, float, float, float, float, int);
float WENO3(float, float, float, float, float, int);
float dist2(float, float, float, float);
float fabs(float);
float sqrt(float);
void Feiko5_WENO3_LxF(int i, int j, float *tao, float *slowMatrix, float slow0,
                      int I, int J, float xmin, float xmax, float ymin,
                      float ymax, float sx, float sy) {
  float slow = slowMatrix[j * I + i];
  float Dx = (xmax - xmin) / (I - 1), Dy = (ymax - ymin) / (J - 1);
  float h = Dx;
  float ax;
  float ay;
  float T0C;
  float taoC = tao[j * I + i];
  float unew = 0.0;
  float ue = 0, uw = 0, un = 0, us = 0;
  float hamilton = 0;
  float ew = 0, ns = 0;
  float x0, y0;
  float p0, q0;
  float r2;
  if (i == 0) {
    unew = Extrapolation4(tao[j * I + i + 5], tao[j * I + i + 4],
                          tao[j * I + i + 3], tao[j * I + i + 2],
                          tao[j * I + i + 1], 1);
  } else if (i == I - 1) {
    unew = Extrapolation4(tao[j * I + i - 5], tao[j * I + i - 4],
                          tao[j * I + i - 3], tao[j * I + i - 2],
                          tao[j * I + i - 1], 1);
  } else if (j == 0) {
    unew = Extrapolation4(tao[(j + 5) * I + i], tao[(j + 4) * I + i],
                          tao[(j + 3) * I + i], tao[(j + 2) * I + i],
                          tao[(j + 1) * I + i], 1);
  } else if (j == J - 1) {
    unew = Extrapolation4(tao[(j - 5) * I + i], tao[(j - 4) * I + i],
                          tao[(j - 3) * I + i], tao[(j - 2) * I + i],
                          tao[(j - 1) * I + i], 1);
  } else {
    if (i == 1) {
      uw = WENO3(Extrapolation4(tao[j * I + i + 3], tao[j * I + i + 2],
                                tao[j * I + i + 1], tao[j * I + i],
                                tao[j * I + i - 1], 1),
                 tao[j * I + i - 1], tao[j * I + i], tao[j * I + i + 1], h, -1);
      ue = WENO3(tao[j * I + i + 2], tao[j * I + i + 1], tao[j * I + i],
                 tao[j * I + i - 1], h, 1);
      uw = taoC - h * uw;
      ue = taoC + h * ue;
    } else if (i == I - 2) {
      uw = WENO3(tao[j * I + i - 2], tao[j * I + i - 1], tao[j * I + i],
                 tao[j * I + i + 1], h, -1);
      ue = WENO3(Extrapolation4(tao[j * I + i - 3], tao[j * I + i - 2],
                                tao[j * I + i - 1], tao[j * I + i],
                                tao[j * I + i + 1], 1),
                 tao[j * I + i + 1], tao[j * I + i], tao[j * I + i - 1], h, 1);
      uw = taoC - h * uw;
      ue = taoC + h * ue;
    } else {
      uw = WENO3(tao[j * I + i - 2], tao[j * I + i - 1], tao[j * I + i],
                 tao[j * I + i + 1], h, -1);
      ue = WENO3(tao[j * I + i + 2], tao[j * I + i + 1], tao[j * I + i],
                 tao[j * I + i - 1], h, 1);
      uw = taoC - h * uw;
      ue = taoC + h * ue;
    }
    if (j == 1) {
      us = WENO3(Extrapolation4(tao[(j + 3) * I + i], tao[(j + 2) * I + i],
                                tao[(j + 1) * I + i], tao[j * I + i],
                                tao[(j - 1) * I + i], 1),
                 tao[(j - 1) * I + i], tao[j * I + i], tao[(j + 1) * I + i], h,
                 -1);
      un = WENO3(tao[(j + 2) * I + i], tao[(j + 1) * I + i], tao[j * I + i],
                 tao[(j - 1) * I + i], h, 1);
      us = taoC - h * us;
      un = taoC + h * un;
    } else if (j == J - 2) {
      us = WENO3(tao[(j - 2) * I + i], tao[(j - 1) * I + i], tao[j * I + i],
                 tao[(j + 1) * I + i], h, -1);
      un = WENO3(Extrapolation4(tao[(j - 3) * I + i], tao[(j - 2) * I + i],
                                tao[(j - 1) * I + i], tao[j * I + i],
                                tao[(j + 1) * I + i], 1),
                 tao[(j + 1) * I + i], tao[j * I + i], tao[(j - 1) * I + i], h,
                 1);
      us = taoC - h * us;
      un = taoC + h * un;
    } else {
      us = WENO3(tao[(j - 2) * I + i], tao[(j - 1) * I + i], tao[j * I + i],
                 tao[(j + 1) * I + i], h, -1);
      un = WENO3(tao[(j + 2) * I + i], tao[(j + 1) * I + i], tao[j * I + i],
                 tao[(j - 1) * I + i], h, 1);
      us = taoC - h * us;
      un = taoC + h * un;
    }
    x0 = i * h + xmin;
    y0 = j * h + ymin;
    r2 = dist2(x0, y0, sx, sy);
    T0C = slow0 * r2;
    if (r2 >= 0.1 * h) {
      p0 = slow0 * (x0 - sx) / r2;
      q0 = slow0 * (y0 - sy) / r2;
    } else {
      p0 = 0;
      q0 = 0;
    }
    ax = (2.5 * (fabs(T0C) + h * (fabs(p0) + fabs(q0))));
    ay = (2.5 * (fabs(T0C) + h * (fabs(p0) + fabs(q0))));
    ew = 0.5 * (ue - uw) / h;
    ns = 0.5 * (un - us) / h;
    hamilton = T0C * T0C * (ew * ew + ns * ns) +
               2.0 * T0C * taoC * (p0 * ew + q0 * ns) +
               taoC * taoC * slow0 * slow0;
    hamilton = sqrt(hamilton);
    unew = (h * slow - h * hamilton + ax * 0.5 * (ue + uw) +
            ay * 0.5 * (un + us)) /
           (ax + ay);
  }
  tao[j * I + i] = unew;
  return;
}


x86 assembly (clang, -O0):
<Feiko5_WENO3_LxF>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
movss  %xmm3,-0x30(%rbp)
movss  %xmm4,-0x34(%rbp)
movss  %xmm5,-0x38(%rbp)
movss  %xmm6,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x34(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    12e9 <Feiko5_WENO3_LxF+0x199>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  %xmm0,-0x60(%rbp)
jmp    21a3 <Feiko5_WENO3_LxF+0x1053>
mov    -0x4(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    138b <Feiko5_WENO3_LxF+0x23b>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  %xmm0,-0x60(%rbp)
jmp    219e <Feiko5_WENO3_LxF+0x104e>
cmpl   $0x0,-0x8(%rbp)
jne    1426 <Feiko5_WENO3_LxF+0x2d6>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x5,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x4,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x3,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  %xmm0,-0x60(%rbp)
jmp    2199 <Feiko5_WENO3_LxF+0x1049>
mov    -0x8(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14c8 <Feiko5_WENO3_LxF+0x378>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x5,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x4,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  %xmm0,-0x60(%rbp)
jmp    2194 <Feiko5_WENO3_LxF+0x1044>
cmpl   $0x1,-0x4(%rbp)
jne    1671 <Feiko5_WENO3_LxF+0x521>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1955 <Feiko5_WENO3_LxF+0x805>
mov    -0x4(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jne    1821 <Feiko5_WENO3_LxF+0x6d1>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1950 <Feiko5_WENO3_LxF+0x800>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1955 <Feiko5_WENO3_LxF+0x805>
cmpl   $0x1,-0x8(%rbp)
jne    1afe <Feiko5_WENO3_LxF+0x9ae>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x3,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1de2 <Feiko5_WENO3_LxF+0xc92>
mov    -0x8(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jne    1cae <Feiko5_WENO3_LxF+0xb5e>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1ddd <Feiko5_WENO3_LxF+0xc8d>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0xffffffff,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x4c(%rbp),%xmm4
mov    $0x1,%edi
call   1060 <WENO3@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
jmp    1de2 <Feiko5_WENO3_LxF+0xc92>
cvtsi2ssl -0x4(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
cvtsi2ssl -0x8(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
movss  -0x38(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
call   1050 <dist2@plt>
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x58(%rbp)
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x1190(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     1ecc <Feiko5_WENO3_LxF+0xd7c>
movss  -0x1c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
subss  -0x38(%rbp),%xmm1
mulss  %xmm1,%xmm0
divss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
subss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
divss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
jmp    1ee2 <Feiko5_WENO3_LxF+0xd92>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x58(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
movss  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movss  -0xa8(%rbp),%xmm2
ff
movss  -0xa4(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movss  -0xa0(%rbp),%xmm0
ff
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x10c2(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x58(%rbp),%xmm0
call   1040 <fabs@plt>
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movss  -0x9c(%rbp),%xmm2
ff
movss  -0x98(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movss  -0x94(%rbp),%xmm0
ff
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1041(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x100e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x6c(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xfde(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm3
movss  -0x7c(%rbp),%xmm2
mulss  -0x7c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xf8d(%rip),%xmm0
mulsd  %xmm2,%xmm0
movss  -0x5c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm4
movss  -0x8c(%rbp),%xmm3
ff
mulss  -0x7c(%rbp),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
mulss  -0x5c(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
call   1070 <sqrt@plt>
movss  %xmm0,-0x74(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xed4(%rip),%xmm2
mulsd  %xmm2,%xmm1
movss  -0x64(%rbp),%xmm2
addss  -0x68(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xea9(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x6c(%rbp),%xmm2
addss  -0x70(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
addss  -0x54(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    2199 <Feiko5_WENO3_LxF+0x1049>
jmp    219e <Feiko5_WENO3_LxF+0x104e>
jmp    21a3 <Feiko5_WENO3_LxF+0x1053>
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
imul   -0x20(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Feiko5_WENO3_LxF>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r14
mov    %r8d,%eax
imul   %esi,%eax
add    %edi,%eax
movslq %eax,%rbp
test   %edi,%edi
je     1198 <Feiko5_WENO3_LxF+0x58>
mov    %r8d,%ebx
mov    %edi,%r12d
lea    -0x1(%rbx),%eax
cmp    %edi,%eax
jne    11c0 <Feiko5_WENO3_LxF+0x80>
movss  -0x14(%r14,%rbp,4),%xmm0
movss  -0x10(%r14,%rbp,4),%xmm1
movss  -0xc(%r14,%rbp,4),%xmm2
movss  -0x8(%r14,%rbp,4),%xmm3
movss  -0x4(%r14,%rbp,4),%xmm4
jmp    126f <Feiko5_WENO3_LxF+0x12f>
movss  0x14(%r14,%rbp,4),%xmm0
movss  0x10(%r14,%rbp,4),%xmm1
movss  0xc(%r14,%rbp,4),%xmm2
movss  0x4(%r14,%rbp,4),%xmm4
movss  0x8(%r14,%rbp,4),%xmm3
jmp    126f <Feiko5_WENO3_LxF+0x12f>
mov    %esi,%r15d
test   %esi,%esi
je     122f <Feiko5_WENO3_LxF+0xef>
mov    %r9d,%r13d
lea    -0x1(%r13),%edx
cmp    %r15d,%edx
jne    1291 <Feiko5_WENO3_LxF+0x151>
lea    -0x5(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm0
lea    -0x4(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm1
lea    -0x3(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm2
lea    -0x2(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm3
add    $0xffffffff,%r15d
imul   %ebx,%r15d
add    %r12d,%r15d
movslq %r15d,%rax
jmp    1269 <Feiko5_WENO3_LxF+0x129>
lea    (%rbx,%rbx,4),%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm0
lea    (%r12,%rbx,4),%eax
cltq
movss  (%r14,%rax,4),%xmm1
lea    (%rbx,%rbx,2),%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm2
lea    (%r12,%rbx,2),%eax
cltq
movss  (%r14,%rax,4),%xmm3
add    %r12d,%ebx
movslq %ebx,%rax
movss  (%r14,%rax,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  %xmm0,(%r14,%rbp,4)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movaps %xmm2,%xmm7
movaps %xmm3,0x90(%rsp)
movaps %xmm6,0x70(%rsp)
movaps %xmm5,0x80(%rsp)
movaps %xmm0,0xa0(%rsp)
movss  (%rcx,%rbp,4),%xmm0
movss  %xmm0,0x5c(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm1,0x60(%rsp)
subss  %xmm1,%xmm7
divss  %xmm0,%xmm7
movss  (%r14,%rbp,4),%xmm6
cmp    $0x1,%r12d
movaps %xmm7,0x20(%rsp)
movss  %xmm6,0x30(%rsp)
jne    135f <Feiko5_WENO3_LxF+0x21f>
movss  0xc(%r14,%rbp,4),%xmm0
movss  0x8(%r14,%rbp,4),%xmm1
lea    (%r14,%rbp,4),%rax
add    $0x4,%rax
mov    %rax,0x8(%rsp)
movss  -0x4(%r14,%rbp,4),%xmm4
movss  0x4(%r14,%rbp,4),%xmm2
lea    -0x4(%r14,%rbp,4),%rax
mov    %rax,0x10(%rsp)
movaps %xmm6,%xmm3
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  -0x4(%r14,%rbp,4),%xmm1
movss  (%r14,%rbp,4),%xmm2
movss  0x4(%r14,%rbp,4),%xmm3
movaps 0x20(%rsp),%xmm4
mov    $0xffffffff,%edi
call   1050 <WENO3@plt>
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
movss  %xmm0,0x4(%rsp)
jmp    13e7 <Feiko5_WENO3_LxF+0x2a7>
lea    -0x2(%rbx),%eax
mov    %eax,0x8(%rsp)
movss  -0x8(%r14,%rbp,4),%xmm0
movss  -0x4(%r14,%rbp,4),%xmm1
movss  0x4(%r14,%rbp,4),%xmm3
movaps %xmm6,%xmm2
movaps %xmm7,%xmm4
mov    $0xffffffff,%edi
call   1050 <WENO3@plt>
movss  %xmm0,0x4(%rsp)
lea    (%r14,%rbp,4),%rdx
add    $0xfffffffffffffffc,%rdx
lea    (%r14,%rbp,4),%rcx
add    $0x4,%rcx
cmp    %r12d,0x8(%rsp)
jne    13e7 <Feiko5_WENO3_LxF+0x2a7>
lea    -0x2(%rbp),%rax
movss  (%r14,%rax,4),%xmm1
movss  (%rdx),%xmm2
movss  -0xc(%r14,%rbp,4),%xmm0
movss  (%r14,%rbp,4),%xmm3
movss  (%rcx),%xmm4
mov    $0x1,%edi
mov    %rcx,0x8(%rsp)
mov    %rdx,0x10(%rsp)
call   1030 <Extrapolation4@plt>
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
jmp    13ee <Feiko5_WENO3_LxF+0x2ae>
movss  0x8(%r14,%rbp,4),%xmm0
movss  (%rcx),%xmm1
movss  (%r14,%rbp,4),%xmm2
movss  (%rdx),%xmm3
movaps 0x20(%rsp),%xmm4
mov    $0x1,%edi
call   1050 <WENO3@plt>
movss  0x4(%rsp),%xmm1
movaps 0x20(%rsp),%xmm4
mulss  %xmm4,%xmm1
movss  %xmm1,0x4(%rsp)
mulss  %xmm4,%xmm0
movss  %xmm0,0x8(%rsp)
cmp    $0x1,%r15d
jne    14c6 <Feiko5_WENO3_LxF+0x386>
lea    (%r12,%rbx,4),%eax
cltq
movss  (%r14,%rax,4),%xmm0
lea    (%rbx,%rbx,2),%eax
add    %r12d,%eax
cltq
mov    %rax,0x18(%rsp)
movss  (%r14,%rax,4),%xmm1
lea    (%r12,%rbx,2),%eax
movslq %eax,%rbx
lea    (%r14,%rbx,4),%rax
mov    %rax,0x50(%rsp)
movss  (%r14,%rbx,4),%xmm2
movss  (%r14,%rbp,4),%xmm3
movslq %r12d,%r13
lea    (%r14,%r13,4),%rax
mov    %rax,0x48(%rsp)
movss  (%r14,%r13,4),%xmm4
mov    $0x1,%edi
call   1030 <Extrapolation4@plt>
movss  (%r14,%r13,4),%xmm1
movss  (%r14,%rbp,4),%xmm2
movss  (%r14,%rbx,4),%xmm3
movaps 0x20(%rsp),%xmm4
mov    $0xffffffff,%edi
call   1050 <WENO3@plt>
mov    0x48(%rsp),%rdx
mov    0x50(%rsp),%rcx
movss  %xmm0,0x10(%rsp)
mov    0x18(%rsp),%rax
jmp    158b <Feiko5_WENO3_LxF+0x44b>
add    $0xfffffffe,%r13d
lea    -0x2(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
mov    %rax,0x48(%rsp)
movss  (%r14,%rax,4),%xmm0
lea    -0x1(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
mov    %rax,0x18(%rsp)
movss  (%r14,%rax,4),%xmm1
movss  (%r14,%rbp,4),%xmm2
lea    0x1(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
mov    %rax,0x50(%rsp)
movss  (%r14,%rax,4),%xmm3
mov    $0xffffffff,%edi
call   1050 <WENO3@plt>
movss  %xmm0,0x10(%rsp)
mov    0x18(%rsp),%rax
lea    (%r14,%rax,4),%rdx
mov    0x50(%rsp),%rax
lea    (%r14,%rax,4),%rcx
cmp    %r15d,%r13d
jne    157f <Feiko5_WENO3_LxF+0x43f>
lea    -0x3(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm0
mov    0x48(%rsp),%rax
movss  (%r14,%rax,4),%xmm1
movss  (%rdx),%xmm2
movss  (%r14,%rbp,4),%xmm3
movss  (%rcx),%xmm4
mov    $0x1,%edi
mov    %rcx,%r13
mov    %rdx,%rbx
call   1030 <Extrapolation4@plt>
mov    %rbx,%rdx
mov    %r13,%rcx
jmp    1591 <Feiko5_WENO3_LxF+0x451>
lea    0x2(%r15),%eax
imul   %ebx,%eax
add    %r12d,%eax
cltq
movss  (%r14,%rax,4),%xmm0
movss  0x30(%rsp),%xmm2
movaps %xmm2,%xmm1
subss  0x4(%rsp),%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x8(%rsp),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x8(%rsp)
movss  (%rcx),%xmm1
movss  (%r14,%rbp,4),%xmm2
movss  (%rdx),%xmm3
movaps 0x20(%rsp),%xmm4
mov    $0x1,%edi
call   1050 <WENO3@plt>
movaps 0x20(%rsp),%xmm2
movss  0x10(%rsp),%xmm3
mulss  %xmm2,%xmm3
movss  0x30(%rsp),%xmm4
movaps %xmm4,%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,0x18(%rsp)
mulss  %xmm2,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x10(%rsp)
movd   %r15d,%xmm0
movd   %r12d,%xmm1
punpckldq %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm0
movaps %xmm2,%xmm1
shufps $0x0,%xmm2,%xmm1
mulps  %xmm0,%xmm1
movaps 0x60(%rsp),%xmm0
unpcklps 0x90(%rsp),%xmm0
addps  %xmm1,%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm0,0x60(%rsp)
movaps 0x80(%rsp),%xmm2
movaps 0x70(%rsp),%xmm3
call   1040 <dist2@plt>
movaps %xmm0,%xmm1
movaps 0xa0(%rsp),%xmm7
mulss  %xmm7,%xmm1
xorps  %xmm4,%xmm4
cvtss2sd %xmm0,%xmm4
movaps 0x20(%rsp),%xmm8
xorps  %xmm3,%xmm3
cvtss2sd %xmm8,%xmm3
movsd  0x988(%rip),%xmm5
mulsd  %xmm3,%xmm5
xorps  %xmm2,%xmm2
ucomisd %xmm5,%xmm4
jb     16ab <Feiko5_WENO3_LxF+0x56b>
movaps 0x80(%rsp),%xmm2
unpcklps 0x70(%rsp),%xmm2
movaps 0x60(%rsp),%xmm4
subps  %xmm2,%xmm4
movaps %xmm7,%xmm2
shufps $0x0,%xmm7,%xmm2
mulps  %xmm4,%xmm2
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm2
movaps 0x95e(%rip),%xmm0
movaps %xmm1,%xmm4
andps  %xmm0,%xmm4
andps  %xmm2,%xmm0
pshufd $0x55,%xmm0,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm8,%xmm6
addss  %xmm4,%xmm6
mulss  0x94b(%rip),%xmm6
movss  0x8(%rsp),%xmm0
subss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x91b(%rip),%xmm4
mulsd  %xmm4,%xmm0
divsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  0x10(%rsp),%xmm5
subss  0x18(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm4,%xmm5
divsd  %xmm3,%xmm5
xorps  %xmm3,%xmm3
cvtsd2ss %xmm5,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
mulss  %xmm1,%xmm1
movaps %xmm2,%xmm5
shufps $0x55,%xmm2,%xmm5
mulss  %xmm3,%xmm5
mulss  %xmm3,%xmm3
mulss  %xmm0,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm4,%xmm4
movss  0x30(%rsp),%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
mulsd  %xmm4,%xmm1
addss  %xmm5,%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
mulss  %xmm3,%xmm3
mulss  %xmm7,%xmm3
mulss  %xmm7,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
xorpd  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1795 <Feiko5_WENO3_LxF+0x655>
sqrtss %xmm0,%xmm0
jmp    17aa <Feiko5_WENO3_LxF+0x66a>
movaps %xmm6,0x30(%rsp)
call   1060 <sqrt@plt>
movaps 0x30(%rsp),%xmm6
movaps 0x20(%rsp),%xmm8
mulss  %xmm8,%xmm0
movss  0x5c(%rsp),%xmm1
mulss  %xmm8,%xmm1
subss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
mulsd  0x834(%rip),%xmm1
movss  0x4(%rsp),%xmm2
addss  0x8(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movss  0x10(%rsp),%xmm0
addss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
addss  %xmm6,%xmm6
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
jmp    1279 <Feiko5_WENO3_LxF+0x139>

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

LLVM IR (-O2):
define void @Feiko5_WENO3_LxF(i32 %0, i32 %1, float* %2, float* nocapture %3, float %4, i32 %5, i32 %6, float %7, float %8, float %9, float %10, float %11, float %12) {
%14 = mul nsw i32 %5, %1
%15 = add nsw i32 %14, %0
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds float, float* %3, i64 %16
%18 = load float, float* %17
%19 = fsub float %8, %7
%20 = add nsw i32 %5, -1
%21 = sitofp i32 %20 to float
%22 = fdiv float %19, %21
%23 = add nsw i32 %6, -1
%24 = getelementptr inbounds float, float* %2, i64 %16
%25 = load float, float* %24
%26 = icmp eq i32 %0, 0
br i1 %26, label %27, label %49
27: ; preds = %13
%28 = add nsw i32 %15, 5
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %2, i64 %29
%31 = load float, float* %30
%32 = add nsw i32 %15, 4
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %2, i64 %33
%35 = load float, float* %34
%36 = add nsw i32 %15, 3
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %2, i64 %37
%39 = load float, float* %38
%40 = add nsw i32 %15, 2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %2, i64 %41
%43 = load float, float* %42
%44 = add nsw i32 %15, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds float, float* %2, i64 %45
%47 = load float, float* %46
%48 = tail call float @Extrapolation4(float %31, float %35, float %39, float %43, float %47, i32 1)
br label %367
49: ; preds = %13
%50 = icmp eq i32 %20, %0
br i1 %50, label %51, label %73
51: ; preds = %49
%52 = add nsw i32 %15, -5
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %2, i64 %53
%55 = load float, float* %54
%56 = add nsw i32 %15, -4
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %2, i64 %57
%59 = load float, float* %58
%60 = add nsw i32 %15, -3
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %2, i64 %61
%63 = load float, float* %62
%64 = add nsw i32 %15, -2
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %2, i64 %65
%67 = load float, float* %66
%68 = add nsw i32 %15, -1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %2, i64 %69
%71 = load float, float* %70
%72 = tail call float @Extrapolation4(float %55, float %59, float %63, float %67, float %71, i32 1)
br label %367
73: ; preds = %49
%74 = icmp eq i32 %1, 0
br i1 %74, label %75, label %101
75: ; preds = %73
%76 = mul nsw i32 %5, 5
%77 = add nsw i32 %76, %0
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %2, i64 %78
%80 = load float, float* %79
%81 = shl nsw i32 %5, 2
%82 = add nsw i32 %81, %0
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %2, i64 %83
%85 = load float, float* %84
%86 = mul nsw i32 %5, 3
%87 = add nsw i32 %86, %0
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %2, i64 %88
%90 = load float, float* %89
%91 = shl nsw i32 %5, 1
%92 = add nsw i32 %91, %0
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %2, i64 %93
%95 = load float, float* %94
%96 = add nsw i32 %5, %0
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %2, i64 %97
%99 = load float, float* %98
%100 = tail call float @Extrapolation4(float %80, float %85, float %90, float %95, float %99, i32 1)
br label %367
101: ; preds = %73
%102 = icmp eq i32 %23, %1
br i1 %102, label %103, label %135
103: ; preds = %101
%104 = add nsw i32 %1, -5
%105 = mul nsw i32 %104, %5
%106 = add nsw i32 %105, %0
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %2, i64 %107
%109 = load float, float* %108
%110 = add nsw i32 %1, -4
%111 = mul nsw i32 %110, %5
%112 = add nsw i32 %111, %0
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %2, i64 %113
%115 = load float, float* %114
%116 = add nsw i32 %1, -3
%117 = mul nsw i32 %116, %5
%118 = add nsw i32 %117, %0
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float, float* %2, i64 %119
%121 = load float, float* %120
%122 = add nsw i32 %1, -2
%123 = mul nsw i32 %122, %5
%124 = add nsw i32 %123, %0
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %2, i64 %125
%127 = load float, float* %126
%128 = add nsw i32 %1, -1
%129 = mul nsw i32 %128, %5
%130 = add nsw i32 %129, %0
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %2, i64 %131
%133 = load float, float* %132
%134 = tail call float @Extrapolation4(float %109, float %115, float %121, float %127, float %133, i32 1)
br label %367
135: ; preds = %101
%136 = icmp eq i32 %0, 1
br i1 %136, label %137, label %160
137: ; preds = %135
%138 = add nsw i32 %15, 3
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float, float* %2, i64 %139
%141 = load float, float* %140
%142 = add nsw i32 %15, 2
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %2, i64 %143
%145 = load float, float* %144
%146 = add nsw i32 %15, 1
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %2, i64 %147
%149 = load float, float* %148
%150 = add nsw i32 %15, -1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %2, i64 %151
%153 = load float, float* %152
%154 = tail call float @Extrapolation4(float %141, float %145, float %149, float %25, float %153, i32 1)
%155 = load float, float* %152
%156 = load float, float* %24
%157 = load float, float* %148
%158 = tail call float @WENO3(float %154, float %155, float %156, float %157, float %22, i32 -1)
%159 = load float, float* %144
br label %191
160: ; preds = %135
%161 = add nsw i32 %5, -2
%162 = icmp eq i32 %161, %0
%163 = add nsw i32 %15, -2
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %2, i64 %164
%166 = load float, float* %165
%167 = add nsw i32 %15, -1
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %2, i64 %168
%170 = load float, float* %169
%171 = add nsw i32 %15, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %2, i64 %172
%174 = load float, float* %173
%175 = tail call float @WENO3(float %166, float %170, float %25, float %174, float %22, i32 -1)
br i1 %162, label %176, label %186
176: ; preds = %160
%177 = add nsw i32 %15, -3
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %2, i64 %178
%180 = load float, float* %179
%181 = load float, float* %165
%182 = load float, float* %169
%183 = load float, float* %24
%184 = load float, float* %173
%185 = tail call float @Extrapolation4(float %180, float %181, float %182, float %183, float %184, i32 1)
br label %191
186: ; preds = %160
%187 = add nsw i32 %15, 2
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %2, i64 %188
%190 = load float, float* %189
br label %191
191: ; preds = %176, %186, %137
%192 = phi float* [ %173, %176 ], [ %173, %186 ], [ %148, %137 ]
%193 = phi float* [ %169, %176 ], [ %169, %186 ], [ %152, %137 ]
%194 = phi float [ %185, %176 ], [ %190, %186 ], [ %159, %137 ]
%195 = phi float [ %175, %176 ], [ %175, %186 ], [ %158, %137 ]
%196 = load float, float* %192
%197 = load float, float* %24
%198 = load float, float* %193
%199 = tail call float @WENO3(float %194, float %196, float %197, float %198, float %22, i32 1)
%200 = fneg float %22
%201 = tail call float @llvm.fmuladd.f32(float %200, float %195, float %25)
%202 = tail call float @llvm.fmuladd.f32(float %22, float %199, float %25)
%203 = icmp eq i32 %1, 1
br i1 %203, label %204, label %230
204: ; preds = %191
%205 = shl nsw i32 %5, 2
%206 = add nsw i32 %205, %0
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %2, i64 %207
%209 = load float, float* %208
%210 = mul nsw i32 %5, 3
%211 = add nsw i32 %210, %0
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float, float* %2, i64 %212
%214 = load float, float* %213
%215 = shl nsw i32 %5, 1
%216 = add nsw i32 %215, %0
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %2, i64 %217
%219 = load float, float* %218
%220 = load float, float* %24
%221 = sext i32 %0 to i64
%222 = getelementptr inbounds float, float* %2, i64 %221
%223 = load float, float* %222
%224 = tail call float @Extrapolation4(float %209, float %214, float %219, float %220, float %223, i32 1)
%225 = load float, float* %222
%226 = load float, float* %24
%227 = load float, float* %218
%228 = tail call float @WENO3(float %224, float %225, float %226, float %227, float %22, i32 -1)
%229 = load float, float* %213
br label %272
230: ; preds = %191
%231 = add nsw i32 %6, -2
%232 = icmp eq i32 %231, %1
%233 = add nsw i32 %1, -2
%234 = mul nsw i32 %233, %5
%235 = add nsw i32 %234, %0
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %2, i64 %236
%238 = load float, float* %237
%239 = add nsw i32 %1, -1
%240 = mul nsw i32 %239, %5
%241 = add nsw i32 %240, %0
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %2, i64 %242
%244 = load float, float* %243
%245 = load float, float* %24
%246 = add nsw i32 %1, 1
%247 = mul nsw i32 %246, %5
%248 = add nsw i32 %247, %0
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %2, i64 %249
%251 = load float, float* %250
%252 = tail call float @WENO3(float %238, float %244, float %245, float %251, float %22, i32 -1)
br i1 %232, label %253, label %265
253: ; preds = %230
%254 = add nsw i32 %1, -3
%255 = mul nsw i32 %254, %5
%256 = add nsw i32 %255, %0
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %2, i64 %257
%259 = load float, float* %258
%260 = load float, float* %237
%261 = load float, float* %243
%262 = load float, float* %24
%263 = load float, float* %250
%264 = tail call float @Extrapolation4(float %259, float %260, float %261, float %262, float %263, i32 1)
br label %272
265: ; preds = %230
%266 = add nsw i32 %1, 2
%267 = mul nsw i32 %266, %5
%268 = add nsw i32 %267, %0
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds float, float* %2, i64 %269
%271 = load float, float* %270
br label %272
272: ; preds = %253, %265, %204
%273 = phi float* [ %250, %253 ], [ %250, %265 ], [ %218, %204 ]
%274 = phi float* [ %243, %253 ], [ %243, %265 ], [ %222, %204 ]
%275 = phi float [ %264, %253 ], [ %271, %265 ], [ %229, %204 ]
%276 = phi float [ %252, %253 ], [ %252, %265 ], [ %228, %204 ]
%277 = load float, float* %273
%278 = load float, float* %24
%279 = load float, float* %274
%280 = tail call float @WENO3(float %275, float %277, float %278, float %279, float %22, i32 1)
%281 = fneg float %22
%282 = tail call float @llvm.fmuladd.f32(float %281, float %276, float %25)
%283 = tail call float @llvm.fmuladd.f32(float %22, float %280, float %25)
%284 = insertelement <2 x i32> poison, i32 %0, i64 0
%285 = insertelement <2 x i32> %284, i32 %1, i64 1
%286 = sitofp <2 x i32> %285 to <2 x float>
%287 = insertelement <2 x float> poison, float %22, i64 0
%288 = shufflevector <2 x float> %287, <2 x float> poison, <2 x i32> zeroinitializer
%289 = insertelement <2 x float> poison, float %7, i64 0
%290 = insertelement <2 x float> %289, float %9, i64 1
%291 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %286, <2 x float> %288, <2 x float> %290)
%292 = extractelement <2 x float> %291, i64 0
%293 = extractelement <2 x float> %291, i64 1
%294 = tail call float @dist2(float %292, float %293, float %11, float %12)
%295 = fmul float %294, %4
%296 = fpext float %294 to double
%297 = fpext float %22 to double
%298 = fmul double %297, 1.000000e-01
%299 = fcmp ugt double %298, %296
br i1 %299, label %310, label %300
300: ; preds = %272
%301 = insertelement <2 x float> poison, float %11, i64 0
%302 = insertelement <2 x float> %301, float %12, i64 1
%303 = fsub <2 x float> %291, %302
%304 = insertelement <2 x float> poison, float %4, i64 0
%305 = shufflevector <2 x float> %304, <2 x float> poison, <2 x i32> zeroinitializer
%306 = fmul <2 x float> %303, %305
%307 = insertelement <2 x float> poison, float %294, i64 0
%308 = shufflevector <2 x float> %307, <2 x float> poison, <2 x i32> zeroinitializer
%309 = fdiv <2 x float> %306, %308
br label %310
310: ; preds = %272, %300
%311 = phi <2 x float> [ %309, %300 ], [ zeroinitializer, %272 ]
%312 = tail call float @llvm.fabs.f32(float %295)
%313 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %311)
%314 = shufflevector <2 x float> %313, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%315 = fadd <2 x float> %313, %314
%316 = extractelement <2 x float> %315, i64 0
%317 = tail call float @llvm.fmuladd.f32(float %22, float %316, float %312)
%318 = fmul float %317, 2.500000e+00
%319 = fsub float %202, %201
%320 = fpext float %319 to double
%321 = fmul double %320, 5.000000e-01
%322 = fdiv double %321, %297
%323 = fptrunc double %322 to float
%324 = fsub float %283, %282
%325 = fpext float %324 to double
%326 = fmul double %325, 5.000000e-01
%327 = fdiv double %326, %297
%328 = fptrunc double %327 to float
%329 = fmul float %295, %295
%330 = fmul float %328, %328
%331 = tail call float @llvm.fmuladd.f32(float %323, float %323, float %330)
%332 = fmul float %329, %331
%333 = fpext float %332 to double
%334 = fpext float %295 to double
%335 = fmul double %334, 2.000000e+00
%336 = fpext float %25 to double
%337 = fmul double %335, %336
%338 = extractelement <2 x float> %311, i64 1
%339 = fmul float %338, %328
%340 = extractelement <2 x float> %311, i64 0
%341 = tail call float @llvm.fmuladd.f32(float %340, float %323, float %339)
%342 = fpext float %341 to double
%343 = tail call double @llvm.fmuladd.f64(double %337, double %342, double %333)
%344 = fmul float %25, %25
%345 = fmul float %344, %4
%346 = fmul float %345, %4
%347 = fpext float %346 to double
%348 = fadd double %343, %347
%349 = fptrunc double %348 to float
%350 = tail call float @sqrt(float %349)
%351 = fneg float %22
%352 = fmul float %350, %351
%353 = tail call float @llvm.fmuladd.f32(float %22, float %18, float %352)
%354 = fpext float %353 to double
%355 = fpext float %318 to double
%356 = fmul double %355, 5.000000e-01
%357 = fadd float %201, %202
%358 = fpext float %357 to double
%359 = tail call double @llvm.fmuladd.f64(double %356, double %358, double %354)
%360 = fadd float %283, %282
%361 = fpext float %360 to double
%362 = tail call double @llvm.fmuladd.f64(double %356, double %361, double %359)
%363 = fadd float %318, %318
%364 = fpext float %363 to double
%365 = fdiv double %362, %364
%366 = fptrunc double %365 to float
br label %367
367: ; preds = %51, %103, %310, %75, %27
%368 = phi float [ %48, %27 ], [ %72, %51 ], [ %100, %75 ], [ %134, %103 ], [ %366, %310 ]
store float %368, float* %24
ret void
}