void fibe2o_f(float s[], int w, int h, float a1, float a2, float rd1, float rd2,
              float rs1, float rs2, float rc1, float rc2, int ec) {
  float cr, g, g4, avg, gavg, avgg, iavg;
  float rep1, rep2;
  int i, j;
  int jw, jww, h1w, h2w, iw, i1w, i2w;
  g = 1.0 / (1.0 + a1 + a2);
  g4 = 1.0 / g / g / g / g;
  avg = 8;
  gavg = g4 / avg;
  avgg = 1.0 / g / avg;
  iavg = 1.0 / avg;
  for (j = 0; j < avg; j++) {
    jw = j * w;
    jww = jw + w;
    cr = 0.0;
    if (ec != 0) {
      for (i = 0; i < avg; i++) {
        cr = cr + s[jw + i];
      }
      cr = cr * gavg;
    }
    s[jw] = g4 * s[jw] - (a1 + a2) * g * cr;
    s[jw + 1] = g4 * s[jw + 1] - a1 * s[jw] - a2 * g * cr;
    if (ec != 0) {
      cr = 0.0;
      for (i = w - avg; i < w; i++) {
        cr = cr + s[jw + i];
      }
      cr = cr * gavg;
    }
    for (i = 2; i < w; i++) {
      s[jw + i] = g4 * s[jw + i] - a1 * s[jw + i - 1] - a2 * s[jw + i - 2];
    }
    rep1 =
        (s[jww - 1] + s[jww - 2]) * 0.5 * rs1 + (s[jww - 1] - s[jww - 2]) * rd1;
    rep2 =
        (s[jww - 1] + s[jww - 2]) * 0.5 * rs2 + (s[jww - 1] - s[jww - 2]) * rd2;
    if (ec != 0) {
      rep1 = rep1 + rc1 * cr;
      rep2 = rep2 + rc2 * cr;
    }
    s[jww - 1] = s[jww - 1] - a1 * rep1 - a2 * rep2;
    s[jww - 2] = s[jww - 2] - a1 * s[jww - 1] - a2 * rep1;
    for (i = w - 3; i >= 0; i--) {
      s[jw + i] = s[jw + i] - a1 * s[jw + i + 1] - a2 * s[jw + i + 2];
    }
  }
  for (j = 0; j < w; j++) {
    cr = 0.0;
    if (ec != 0) {
      for (i = 0; i < avg; i++) {
        cr = cr + s[j + w * i];
      }
      cr = cr * iavg;
    }
    s[j] = s[j] - (a1 + a2) * g * cr;
    s[j + w] = s[j + w] - a1 * s[j] - a2 * g * cr;
  }
  for (i = 2; i < avg; i++) {
    iw = i * w;
    i1w = iw - w;
    for (j = 0; j < w; j++) {
      s[j + iw] = s[j + iw] - a1 * s[j + i1w] - a2 * s[j + i1w - w];
    }
  }
  for (j = avg; j < h; j++) {
    jw = j * w;
    jww = jw + w;
    cr = 0.0;
    if (ec != 0) {
      for (i = 0; i < avg; i++) {
        cr = cr + s[jw + i];
      }
      cr = cr * gavg;
    }
    s[jw] = g4 * s[jw] - (a1 + a2) * g * cr;
    s[jw + 1] = g4 * s[jw + 1] - a1 * s[jw] - a2 * g * cr;
    if (ec != 0) {
      cr = 0.0;
      for (i = w - avg; i < w; i++) {
        cr = cr + s[jw + i];
      }
      cr = cr * gavg;
    }
    for (i = 2; i < w; i++) {
      s[jw + i] = g4 * s[jw + i] - a1 * s[jw + i - 1] - a2 * s[jw + i - 2];
    }
    rep1 =
        (s[jww - 1] + s[jww - 2]) * 0.5 * rs1 + (s[jww - 1] - s[jww - 2]) * rd1;
    rep2 =
        (s[jww - 1] + s[jww - 2]) * 0.5 * rs2 + (s[jww - 1] - s[jww - 2]) * rd2;
    if (ec != 0) {
      rep1 = rep1 + rc1 * cr;
      rep2 = rep2 + rc2 * cr;
    }
    s[jww - 1] = s[jww - 1] - a1 * rep1 - a2 * rep2;
    s[jww - 2] = s[jww - 2] - a1 * s[jww - 1] - a2 * rep1;
    for (i = w - 3; i >= 0; i--) {
      s[jw + i] = s[jw + i] - a1 * s[jw + i + 1] - a2 * s[jw + i + 2];
      s[jw + i + 2] =
          s[jw + i + 2] - a1 * s[jw - w + i + 2] - a2 * s[jw - w - w + i + 2];
    }
    s[jw + 1] = s[jw + 1] - a1 * s[jw - w + 1] - a2 * s[jw - w - w + 1];
    s[jw] = s[jw] - a1 * s[jw - w] - a2 * s[jw - w - w];
  }
  h1w = (h - 1) * w;
  h2w = (h - 2) * w;
  for (j = 0; j < w; j++) {
    if (ec != 0) {
      cr = 0.0;
      for (i = h - avg; i < h; i++) {
        cr = cr + s[j + w * i];
      }
      cr = cr * avgg;
    }
    rep1 =
        (s[j + h1w] + s[j + h2w]) * 0.5 * rs1 + (s[j + h1w] - s[j + h2w]) * rd1;
    rep2 =
        (s[j + h1w] + s[j + h2w]) * 0.5 * rs2 + (s[j + h1w] - s[j + h2w]) * rd2;
    if (ec != 0) {
      rep1 = rep1 + rc1 * cr;
      rep2 = rep2 + rc2 * cr;
    }
    s[j + h1w] = s[j + h1w] - a1 * rep1 - a2 * rep2;
    s[j + h2w] = s[j + h2w] - a1 * s[j + h1w] - a2 * rep1;
  }
  for (i = h - 3; i >= 0; i--) {
    iw = i * w;
    i1w = iw + w;
    i2w = i1w + w;
    for (j = 0; j < w; j++) {
      s[j + iw] = s[j + iw] - a1 * s[j + i1w] - a2 * s[j + i2w];
    }
  }
}


x86 assembly (clang, -O0):
<fibe2o_f>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  %xmm2,-0x1c(%rbp)
movss  %xmm3,-0x20(%rbp)
movss  %xmm4,-0x24(%rbp)
movss  %xmm5,-0x28(%rbp)
movss  %xmm6,-0x2c(%rbp)
movss  %xmm7,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1eb6(%rip),%xmm1
addsd  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
movsd  0x1e9d(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e7f(%rip),%xmm0
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0x1e53(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e1e(%rip),%xmm0
divsd  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1df3(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x60(%rbp)
cvtsi2ssl -0x60(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1737 <fibe2o_f+0x637>
mov    -0x60(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     12ac <fibe2o_f+0x1ac>
movl   $0x0,-0x5c(%rbp)
cvtsi2ssl -0x5c(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    129d <fibe2o_f+0x19d>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1260 <fibe2o_f+0x160>
movss  -0x38(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm1
addss  -0x18(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x34(%rbp)
je     13d0 <fibe2o_f+0x2d0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl -0xc(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c1 <fibe2o_f+0x2c1>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    138b <fibe2o_f+0x28b>
movss  -0x38(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x2,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1478 <fibe2o_f+0x378>
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13d7 <fibe2o_f+0x2d7>
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b60(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1ae5(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     15b0 <fibe2o_f+0x4b0>
movss  -0x54(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jl     1724 <fibe2o_f+0x624>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    168a <fibe2o_f+0x58a>
jmp    1729 <fibe2o_f+0x629>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1221 <fibe2o_f+0x121>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1875 <fibe2o_f+0x775>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     17b5 <fibe2o_f+0x6b5>
movl   $0x0,-0x5c(%rbp)
cvtsi2ssl -0x5c(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    17a6 <fibe2o_f+0x6a6>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x5c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1763 <fibe2o_f+0x663>
movss  -0x38(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x14(%rbp),%xmm0
addss  -0x18(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    173e <fibe2o_f+0x63e>
movl   $0x2,-0x5c(%rbp)
cvtsi2ssl -0x5c(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1955 <fibe2o_f+0x855>
mov    -0x5c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x78(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1942 <fibe2o_f+0x842>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x78(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    18a9 <fibe2o_f+0x7a9>
jmp    1947 <fibe2o_f+0x847>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    187c <fibe2o_f+0x77c>
cvttss2si -0x44(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ff2 <fibe2o_f+0xef2>
mov    -0x60(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     19e1 <fibe2o_f+0x8e1>
movl   $0x0,-0x5c(%rbp)
cvtsi2ssl -0x5c(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    19d2 <fibe2o_f+0x8d2>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1995 <fibe2o_f+0x895>
movss  -0x38(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm1
addss  -0x18(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x34(%rbp)
je     1b05 <fibe2o_f+0xa05>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl -0xc(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1af6 <fibe2o_f+0x9f6>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1ac0 <fibe2o_f+0x9c0>
movss  -0x38(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x2,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bad <fibe2o_f+0xaad>
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1b0c <fibe2o_f+0xa0c>
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x142b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13b0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     1ce5 <fibe2o_f+0xbe5>
movss  -0x54(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jl     1eea <fibe2o_f+0xdea>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    1dbf <fibe2o_f+0xcbf>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    195d <fibe2o_f+0x85d>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x2,%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    22a4 <fibe2o_f+0x11a4>
cmpl   $0x0,-0x34(%rbp)
je     208d <fibe2o_f+0xf8d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    207e <fibe2o_f+0xf7e>
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x5c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2042 <fibe2o_f+0xf42>
movss  -0x38(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf4b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x1c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xed0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mulss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     21c5 <fibe2o_f+0x10c5>
movss  -0x54(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2013 <fibe2o_f+0xf13>
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jl     2383 <fibe2o_f+0x1283>
mov    -0x5c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2370 <fibe2o_f+0x1270>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    22da <fibe2o_f+0x11da>
jmp    2375 <fibe2o_f+0x1275>
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    22ad <fibe2o_f+0x11ad>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fibe2o_f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x30,%rsp
movaps %xmm0,%xmm8
cvtss2sd %xmm0,%xmm9
movsd  0x1ee0(%rip),%xmm11
addsd  %xmm11,%xmm9
cvtss2sd %xmm1,%xmm10
addsd  %xmm9,%xmm10
movapd %xmm11,%xmm0
divsd  %xmm10,%xmm0
cvtsd2ss %xmm0,%xmm12
xorps  %xmm9,%xmm9
cvtss2sd %xmm12,%xmm9
divsd  %xmm9,%xmm11
movapd %xmm11,%xmm0
divsd  %xmm9,%xmm0
divsd  %xmm9,%xmm0
divsd  %xmm9,%xmm0
cvtsd2ss %xmm0,%xmm13
movss  %xmm7,-0x20(%rsp)
movss  %xmm6,-0x28(%rsp)
mov    %rdx,-0x50(%rsp)
mov    %esi,%r11d
movss  0x1e96(%rip),%xmm14
mulsd  0x1e7d(%rip),%xmm11
movsd  %xmm11,0x28(%rsp)
mulss  %xmm13,%xmm14
movaps %xmm8,%xmm10
addss  %xmm1,%xmm10
movaps 0x1e89(%rip),%xmm0
xorps  %xmm0,%xmm10
mulss  %xmm12,%xmm10
xorps  %xmm0,%xmm12
mulss  %xmm1,%xmm12
cvtss2sd %xmm4,%xmm4
movsd  %xmm4,-0x10(%rsp)
xorps  %xmm4,%xmm4
cvtss2sd %xmm5,%xmm4
movsd  %xmm4,-0x18(%rsp)
movaps %xmm8,%xmm15
xorps  %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
xorps  %xmm0,%xmm15
xorps  %xmm0,%xmm1
addss  0x1e32(%rip),%xmm4
lea    -0x3(%r11),%eax
cvttss2si %xmm4,%r12d
movslq %r12d,%r13
movslq %eax,%rdx
movslq %esi,%rbx
mov    %ebx,%eax
mov    %rbx,%r14
sub    %r13,%r14
mov    %r13,%rsi
not    %rsi
add    %rbx,%rsi
mov    %rsi,-0x38(%rsp)
lea    -0x2(%rax),%r9
mov    %rax,-0x80(%rsp)
add    $0xfffffffffffffffd,%rax
mov    %rax,-0x30(%rsp)
mov    %r14,%rax
mov    %r14,-0x58(%rsp)
and    $0x3,%r14d
lea    0x0(,%rbx,4),%r15
and    $0xfffffffffffffffe,%r9
neg    %r9
mov    %rdx,(%rsp)
lea    0x1(%rdx),%r10
xor    %r8d,%r8d
mov    %rdi,%rdx
mov    %rbx,-0x78(%rsp)
jmp    1276 <fibe2o_f+0x176>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %r15,%rdx
cmp    $0x8,%r8
mov    -0x78(%rsp),%rbx
je     1554 <fibe2o_f+0x454>
mov    %r8,%rbp
imul   %rbx,%rbp
movss  (%rdi,%rbp,4),%xmm7
test   %ecx,%ecx
je     12d0 <fibe2o_f+0x1d0>
movaps %xmm7,%xmm5
addss  0x1d8f(%rip),%xmm5
movss  0x4(%rdi,%rbp,4),%xmm4
addss  %xmm4,%xmm5
addss  0x8(%rdi,%rbp,4),%xmm5
addss  0xc(%rdi,%rbp,4),%xmm5
addss  0x10(%rdi,%rbp,4),%xmm5
addss  0x14(%rdi,%rbp,4),%xmm5
addss  0x18(%rdi,%rbp,4),%xmm5
lea    0x1(%rbp),%rsi
addss  0x1c(%rdi,%rbp,4),%xmm5
mulss  %xmm14,%xmm5
jmp    12dd <fibe2o_f+0x1dd>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%rsi
movss  0x4(%rdi,%rbp,4),%xmm4
xorps  %xmm5,%xmm5
movaps %xmm10,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm13,%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,(%rdi,%rbp,4)
mulss  %xmm8,%xmm7
mulss  %xmm13,%xmm4
subss  %xmm7,%xmm4
movaps %xmm12,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rsi,4)
test   %ecx,%ecx
je     1385 <fibe2o_f+0x285>
xorps  %xmm5,%xmm5
cmp    %r11d,%r12d
jge    1380 <fibe2o_f+0x280>
xorps  %xmm5,%xmm5
test   %r14,%r14
je     1341 <fibe2o_f+0x241>
mov    %r14,%rbx
mov    %r13,%rsi
nopl   0x0(%rax)
addss  (%rdx,%rsi,4),%xmm5
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    1330 <fibe2o_f+0x230>
jmp    1344 <fibe2o_f+0x244>
mov    %r13,%rsi
cmpq   $0x3,-0x38(%rsp)
mov    -0x78(%rsp),%rbx
jb     1380 <fibe2o_f+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addss  (%rdx,%rsi,4),%xmm5
addss  0x4(%rdx,%rsi,4),%xmm5
addss  0x8(%rdx,%rsi,4),%xmm5
addss  0xc(%rdx,%rsi,4),%xmm5
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    1360 <fibe2o_f+0x260>
mulss  %xmm14,%xmm5
add    %rbp,%rbx
cmp    $0x3,%r11d
jl     1440 <fibe2o_f+0x340>
movss  0x4(%rdi,%rbp,4),%xmm7
cmpq   $0x0,-0x30(%rsp)
je     153f <fibe2o_f+0x43f>
mov    $0x2,%esi
nopl   0x0(%rax)
mulss  %xmm8,%xmm7
movss  (%rdx,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm7,%xmm0
movss  -0x8(%rdx,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdx,%rsi,4)
mulss  %xmm8,%xmm4
movss  0x4(%rdx,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm4,%xmm0
movss  -0x4(%rdx,%rsi,4),%xmm7
mulss  %xmm1,%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,0x4(%rdx,%rsi,4)
lea    (%r9,%rsi,1),%rax
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x2,%rax
jne    13b0 <fibe2o_f+0x2b0>
testb  $0x1,-0x80(%rsp)
je     1440 <fibe2o_f+0x340>
add    %rbp,%rsi
mulss  %xmm8,%xmm7
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm7,%xmm0
movss  -0x8(%rdi,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdi,%rsi,4)
movss  -0x8(%rdi,%rbx,4),%xmm9
movss  -0x4(%rdi,%rbx,4),%xmm7
movaps %xmm7,%xmm0
addss  %xmm9,%xmm0
xorps  %xmm11,%xmm11
cvtss2sd %xmm0,%xmm11
mulsd  0x1ba9(%rip),%xmm11
movaps %xmm7,%xmm4
subss  %xmm9,%xmm4
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
cvtss2sd %xmm6,%xmm6
movapd %xmm11,%xmm0
mulsd  -0x10(%rsp),%xmm0
addsd  %xmm6,%xmm0
xorps  %xmm6,%xmm6
cvtsd2ss %xmm0,%xmm6
mulss  %xmm3,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
mulsd  -0x18(%rsp),%xmm11
addsd  %xmm0,%xmm11
xorps  %xmm0,%xmm0
cvtsd2ss %xmm11,%xmm0
test   %ecx,%ecx
je     14cf <fibe2o_f+0x3cf>
movss  -0x28(%rsp),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm4,%xmm6
movss  -0x20(%rsp),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm4,%xmm0
movaps %xmm15,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm7,%xmm4
mulss  %xmm1,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x4(%rdi,%rbx,4)
mulss  %xmm15,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
movss  %xmm6,-0x8(%rdi,%rbx,4)
cmp    $0x3,%r11d
jl     1260 <fibe2o_f+0x160>
mov    %r10,%rsi
xchg   %ax,%ax
movss  (%rdx,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  -0x4(%rdx,%rsi,4),%xmm0
movss  0x4(%rdx,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,-0x4(%rdx,%rsi,4)
add    $0xffffffffffffffff,%rsi
jg     1510 <fibe2o_f+0x410>
jmp    1260 <fibe2o_f+0x160>
mov    $0x2,%esi
testb  $0x1,-0x80(%rsp)
jne    1417 <fibe2o_f+0x317>
jmp    1440 <fibe2o_f+0x340>
mov    %r13,0x18(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15,-0x48(%rsp)
test   %r11d,%r11d
mov    %r11,-0x70(%rsp)
jle    1ffd <fibe2o_f+0xefd>
lea    (%rbx,%rbx,1),%r11
lea    (%rbx,%rbx,2),%rsi
lea    (%rbx,%rbx,4),%rax
lea    (%r11,%r11,2),%rbp
lea    0x0(,%rbx,8),%r15
sub    %rbx,%r15
lea    (%rdi,%rbx,4),%r10
mov    %rbx,%rdx
lea    (%rdi,%rbx,8),%rbx
mov    %rsi,-0x60(%rsp)
lea    (%rdi,%rsi,4),%r8
shl    $0x4,%rdx
add    %rdi,%rdx
mov    %rax,-0x8(%rsp)
lea    (%rdi,%rax,4),%r13
lea    (%rdi,%rbp,4),%r14
lea    (%rdi,%r15,4),%r12
xor    %esi,%esi
xorpd  %xmm11,%xmm11
movss  0x1a50(%rip),%xmm9
jmp    1645 <fibe2o_f+0x545>
nopw   0x0(%rax,%rax,1)
movaps %xmm0,%xmm5
addss  %xmm11,%xmm5
addss  (%r10,%rsi,4),%xmm5
addss  (%rbx,%rsi,4),%xmm5
addss  (%r8,%rsi,4),%xmm5
addss  (%rdx,%rsi,4),%xmm5
addss  0x0(%r13,%rsi,4),%xmm5
addss  (%r14,%rsi,4),%xmm5
mov    -0x78(%rsp),%rax
add    %rsi,%rax
addss  (%r12,%rsi,4),%xmm5
mulss  %xmm9,%xmm5
movaps %xmm10,%xmm4
mulss  %xmm5,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdi,%rsi,4)
mulss  %xmm15,%xmm4
addss  (%rdi,%rax,4),%xmm4
movaps %xmm12,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rsi
cmp    %rsi,-0x80(%rsp)
je     165b <fibe2o_f+0x55b>
movss  (%rdi,%rsi,4),%xmm0
test   %ecx,%ecx
jne    15d0 <fibe2o_f+0x4d0>
mov    -0x78(%rsp),%rax
add    %rsi,%rax
xorps  %xmm5,%xmm5
jmp    160e <fibe2o_f+0x50e>
mov    -0x70(%rsp),%rsi
test   %esi,%esi
jle    170c <fibe2o_f+0x60c>
cmp    $0x8,%esi
mov    %rbp,0x10(%rsp)
jae    1714 <fibe2o_f+0x614>
xor    %ebx,%ebx
mov    -0x80(%rsp),%rbp
mov    %rbx,%rdx
shl    $0x20,%rdx
lea    (%rdi,%r11,4),%rsi
movabs $0x100000000,%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rbx,%rbp,1),%eax
cltq
movss  (%rdi,%rax,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%rsi,%rbx,4),%xmm0
mov    %rdx,%rax
sar    $0x1e,%rax
movss  (%rdi,%rax,1),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rsi,%rbx,4)
add    $0x1,%rbx
add    %r10,%rdx
cmp    %rbx,%rbp
jne    16a0 <fibe2o_f+0x5a0>
mov    -0x70(%rsp),%r11
test   %r11d,%r11d
jle    1ff8 <fibe2o_f+0xef8>
lea    (%r11,%r11,1),%esi
mov    %esi,%r10d
cmp    $0x8,%r11d
mov    %rsi,%rax
mov    %rsi,-0x40(%rsp)
jae    1830 <fibe2o_f+0x730>
xor    %ebx,%ebx
mov    -0x80(%rsp),%rbp
jmp    1980 <fibe2o_f+0x880>
mov    %rsi,%r11
jmp    1ff8 <fibe2o_f+0xef8>
mov    -0x80(%rsp),%rax
add    $0xffffffffffffffff,%rax
lea    (%rax,%rsi,1),%edx
xor    %ebx,%ebx
cmp    %esi,%edx
jl     1678 <fibe2o_f+0x578>
shr    $0x20,%rax
mov    -0x80(%rsp),%rbp
jne    167d <fibe2o_f+0x57d>
lea    (%rdi,%r11,4),%rax
lea    (%r11,%rbp,1),%rdx
lea    (%rdi,%rdx,4),%rdx
mov    -0x78(%rsp),%rsi
add    %rbp,%rsi
lea    (%rdi,%rsi,4),%rsi
lea    (%rdi,%rbp,4),%rbx
cmp    %rsi,%rax
setb   %sil
cmp    %rdx,%r10
setb   %r10b
cmp    %rbx,%rax
setb   %al
cmp    %rdi,%rdx
seta   %dl
xor    %ebx,%ebx
test   %r10b,%sil
jne    1678 <fibe2o_f+0x578>
and    %dl,%al
mov    -0x80(%rsp),%rbp
jne    167d <fibe2o_f+0x57d>
mov    %r15,-0x68(%rsp)
mov    %ebp,%ebx
and    $0xfffffff8,%ebx
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
lea    (%rdi,%r11,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
movabs $0x800000000,%r15
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%r10,4),%xmm0
movups (%rdx,%r10,4),%xmm4
lea    (%r10,%rbp,1),%eax
cltq
movups (%rdi,%rax,4),%xmm7
movups 0x10(%rdi,%rax,4),%xmm6
mulps  %xmm9,%xmm7
addps  %xmm0,%xmm7
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
mov    %rsi,%rax
sar    $0x1e,%rax
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm7,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm6,%xmm4
movups %xmm0,-0x10(%rdx,%r10,4)
movups %xmm4,(%rdx,%r10,4)
add    $0x8,%r10
add    %r15,%rsi
cmp    %r10,%rbx
jne    17c0 <fibe2o_f+0x6c0>
cmp    %rbp,%rbx
mov    -0x68(%rsp),%r15
jne    167d <fibe2o_f+0x57d>
jmp    16d9 <fibe2o_f+0x5d9>
mov    -0x80(%rsp),%rax
add    $0xffffffffffffffff,%rax
lea    (%rsi,%rax,1),%edx
xor    %ebx,%ebx
cmp    %esi,%edx
jl     195c <fibe2o_f+0x85c>
shr    $0x20,%rax
mov    -0x80(%rsp),%rbp
jne    1980 <fibe2o_f+0x880>
mov    %r15,-0x68(%rsp)
mov    -0x60(%rsp),%rax
add    %rbp,%rax
lea    (%rdi,%rax,4),%rdx
movslq -0x40(%rsp),%rax
lea    (%rdi,%rax,4),%rsi
mov    %rsi,0x20(%rsp)
lea    (%rax,%rbp,1),%rbx
lea    (%rdi,%rbx,4),%r15
mov    -0x78(%rsp),%rsi
sub    %rsi,%rax
lea    (%rdi,%rax,4),%r11
sub    %rsi,%rbx
lea    (%rdi,%rbx,4),%rax
cmp    %r15,%r8
setb   %sil
cmp    %rdx,0x20(%rsp)
setb   %bpl
cmp    %rax,%r8
setb   %al
cmp    %rdx,%r11
setb   %dl
xor    %ebx,%ebx
test   %bpl,%sil
jne    1963 <fibe2o_f+0x863>
and    %dl,%al
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%rbp
mov    -0x68(%rsp),%r15
jne    1980 <fibe2o_f+0x880>
mov    %ebp,%ebx
and    $0xfffffff8,%ebx
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
mov    -0x60(%rsp),%rax
lea    (%rdi,%rax,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rsi,4),%xmm0
movups (%rdx,%rsi,4),%xmm4
lea    (%r10,%rsi,1),%eax
cltq
movups (%rdi,%rax,4),%xmm6
movups 0x10(%rdi,%rax,4),%xmm7
mulps  %xmm9,%xmm6
addps  %xmm0,%xmm6
mulps  %xmm9,%xmm7
addps  %xmm4,%xmm7
lea    0x0(%rbp,%rsi,1),%eax
cltq
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm7,%xmm4
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm4,(%rdx,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    1900 <fibe2o_f+0x800>
cmp    %rbp,%rbx
jne    1980 <fibe2o_f+0x880>
jmp    19b8 <fibe2o_f+0x8b8>
mov    -0x80(%rsp),%rbp
jmp    1980 <fibe2o_f+0x880>
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%rbp
mov    -0x68(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rbx,1),%eax
cltq
movss  (%rdi,%rax,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%r8,%rbx,4),%xmm0
lea    0x0(%rbp,%rbx,1),%eax
cltq
movss  (%rdi,%rax,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%r8,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1980 <fibe2o_f+0x880>
test   %r11d,%r11d
jle    1ff8 <fibe2o_f+0xef8>
lea    (%r11,%r11,2),%edx
mov    %edx,%r10d
cmp    $0x8,%r11d
mov    -0x80(%rsp),%r8
jae    1b0d <fibe2o_f+0xa0d>
xor    %ebp,%ebp
mov    -0x40(%rsp),%rax
mov    -0x48(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
nopw   0x0(%rax,%rax,1)
lea    (%r10,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%rdx,%rbp,4),%xmm0
lea    (%rax,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r8
jne    19f0 <fibe2o_f+0x8f0>
test   %r11d,%r11d
jle    1ff8 <fibe2o_f+0xef8>
lea    0x0(,%r11,4),%r10d
mov    %r10d,%eax
cmp    $0x8,%r11d
jae    1c34 <fibe2o_f+0xb34>
xor    %ebp,%ebp
lea    (%r11,%r11,2),%edx
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  0x0(%r13,%rbp,4),%xmm0
lea    (%rdx,%rbp,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,0x0(%r13,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r8
jne    1a50 <fibe2o_f+0x950>
test   %r11d,%r11d
jle    1ff8 <fibe2o_f+0xef8>
lea    (%r11,%r11,4),%esi
mov    %esi,%eax
cmp    $0x8,%r11d
jae    1d59 <fibe2o_f+0xc59>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%rdx,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%r14,%rdx,4),%xmm0
lea    (%r10,%rdx,1),%esi
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%r14,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1ab0 <fibe2o_f+0x9b0>
test   %r11d,%r11d
jle    1ff8 <fibe2o_f+0xef8>
mov    -0x40(%rsp),%rax
lea    (%rax,%rax,2),%esi
mov    %esi,%eax
cmp    $0x8,%r11d
jae    1e74 <fibe2o_f+0xd74>
xor    %edx,%edx
jmp    1fb7 <fibe2o_f+0xeb7>
lea    -0x1(%r8),%rsi
lea    (%rdx,%rsi,1),%ebx
xor    %ebp,%ebp
cmp    %edx,%ebx
mov    -0x40(%rsp),%rax
jl     19de <fibe2o_f+0x8de>
shr    $0x20,%rsi
jne    19de <fibe2o_f+0x8de>
mov    %r15,-0x68(%rsp)
mov    -0x48(%rsp),%rsi
lea    (%rdi,%rsi,4),%r15
lea    (%rsi,%r8,1),%rbp
lea    (%rdi,%rbp,4),%rbp
movslq %edx,%rdx
mov    %r8,%rsi
lea    (%rdi,%rdx,4),%r8
lea    (%rdx,%rsi,1),%rbx
lea    (%rdi,%rbx,4),%rax
mov    -0x78(%rsp),%rsi
sub    %rsi,%rdx
lea    (%rdi,%rdx,4),%r11
sub    %rsi,%rbx
lea    (%rdi,%rbx,4),%rdx
cmp    %rax,%r15
setb   %al
cmp    %rbp,%r8
setb   %bl
cmp    %rdx,%r15
setb   %dl
cmp    %rbp,%r11
setb   %sil
xor    %ebp,%ebp
test   %bl,%al
jne    1f7b <fibe2o_f+0xe7b>
and    %sil,%dl
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
mov    -0x68(%rsp),%r15
mov    -0x40(%rsp),%rax
jne    19de <fibe2o_f+0x8de>
mov    %r8d,%ebp
and    $0xfffffff8,%ebp
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
mov    -0x48(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
nop
movups -0x10(%rdx,%rsi,4),%xmm0
movups (%rdx,%rsi,4),%xmm4
lea    (%r10,%rsi,1),%ebx
movslq %ebx,%rbx
movups (%rdi,%rbx,4),%xmm7
movups 0x10(%rdi,%rbx,4),%xmm6
mulps  %xmm9,%xmm7
addps  %xmm0,%xmm7
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
lea    (%rax,%rsi,1),%ebx
movslq %ebx,%rbx
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm7,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm6,%xmm4
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm4,(%rdx,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rbp
jne    1bd0 <fibe2o_f+0xad0>
cmp    %r8,%rbp
jne    19de <fibe2o_f+0x8de>
jmp    1a27 <fibe2o_f+0x927>
lea    -0x1(%r8),%rdx
lea    (%r10,%rdx,1),%esi
xor    %ebp,%ebp
cmp    %r10d,%esi
jl     1a47 <fibe2o_f+0x947>
shr    $0x20,%rdx
jne    1a47 <fibe2o_f+0x947>
mov    %r15,-0x68(%rsp)
mov    -0x8(%rsp),%rdx
add    %r8,%rdx
lea    (%rdi,%rdx,4),%rsi
movslq %r10d,%rdx
mov    %r8,%rbp
lea    (%rdi,%rdx,4),%r8
lea    (%rdx,%rbp,1),%rbx
lea    (%rdi,%rbx,4),%r15
mov    -0x78(%rsp),%rbp
sub    %rbp,%rdx
lea    (%rdi,%rdx,4),%r11
sub    %rbp,%rbx
lea    (%rdi,%rbx,4),%rdx
cmp    %r15,%r13
setb   %r15b
cmp    %rsi,%r8
setb   %bl
cmp    %rdx,%r13
setb   %dl
cmp    %rsi,%r11
setb   %sil
xor    %ebp,%ebp
test   %bl,%r15b
jne    1f8f <fibe2o_f+0xe8f>
and    %sil,%dl
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
mov    -0x68(%rsp),%r15
jne    1a47 <fibe2o_f+0x947>
mov    %r8d,%ebp
and    $0xfffffff8,%ebp
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
mov    -0x8(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
add    $0x10,%rdx
lea    (%r11,%r11,2),%r8d
xor    %ebx,%ebx
nop
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm4
lea    (%rax,%rbx,1),%esi
movslq %esi,%rsi
movups (%rdi,%rsi,4),%xmm6
movups 0x10(%rdi,%rsi,4),%xmm7
mulps  %xmm9,%xmm6
addps  %xmm0,%xmm6
mulps  %xmm9,%xmm7
addps  %xmm4,%xmm7
lea    (%r8,%rbx,1),%esi
movslq %esi,%rsi
movups (%rdi,%rsi,4),%xmm0
movups 0x10(%rdi,%rsi,4),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm7,%xmm4
movups %xmm0,-0x10(%rdx,%rbx,4)
movups %xmm4,(%rdx,%rbx,4)
add    $0x8,%rbx
cmp    %rbx,%rbp
jne    1cf0 <fibe2o_f+0xbf0>
mov    -0x80(%rsp),%r8
cmp    %r8,%rbp
jne    1a47 <fibe2o_f+0x947>
jmp    1a8a <fibe2o_f+0x98a>
lea    -0x1(%r8),%rbp
lea    (%rsi,%rbp,1),%ebx
xor    %edx,%edx
cmp    %esi,%ebx
jl     1ab0 <fibe2o_f+0x9b0>
shr    $0x20,%rbp
jne    1ab0 <fibe2o_f+0x9b0>
mov    0x10(%rsp),%rdx
add    %r8,%rdx
lea    (%rdi,%rdx,4),%rdx
movslq %esi,%rsi
mov    %r8,%rbp
lea    (%rdi,%rsi,4),%r8
lea    (%rsi,%rbp,1),%rbx
lea    (%rdi,%rbx,4),%r11
mov    -0x78(%rsp),%rbp
sub    %rbp,%rsi
lea    (%rdi,%rsi,4),%rsi
sub    %rbp,%rbx
lea    (%rdi,%rbx,4),%rbx
cmp    %r11,%r14
setb   %r11b
cmp    %rdx,%r8
setb   %r8b
cmp    %rbx,%r14
setb   %bl
cmp    %rdx,%rsi
setb   %sil
xor    %edx,%edx
test   %r8b,%r11b
jne    1fa3 <fibe2o_f+0xea3>
and    %sil,%bl
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
jne    1ab0 <fibe2o_f+0x9b0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
mov    0x10(%rsp),%rsi
lea    (%rdi,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rbp,4),%xmm0
movups (%rsi,%rbp,4),%xmm4
lea    (%rax,%rbp,1),%ebx
movslq %ebx,%rbx
movups (%rdi,%rbx,4),%xmm7
movups 0x10(%rdi,%rbx,4),%xmm6
mulps  %xmm9,%xmm7
addps  %xmm0,%xmm7
mulps  %xmm9,%xmm6
addps  %xmm4,%xmm6
lea    (%r10,%rbp,1),%ebx
movslq %ebx,%rbx
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm7,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm6,%xmm4
movups %xmm0,-0x10(%rsi,%rbp,4)
movups %xmm4,(%rsi,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%rdx
jne    1e10 <fibe2o_f+0xd10>
cmp    %r8,%rdx
jne    1ab0 <fibe2o_f+0x9b0>
jmp    1ae9 <fibe2o_f+0x9e9>
lea    -0x1(%r8),%rbp
lea    (%rsi,%rbp,1),%ebx
xor    %edx,%edx
cmp    %esi,%ebx
jl     1fb7 <fibe2o_f+0xeb7>
shr    $0x20,%rbp
jne    1fb7 <fibe2o_f+0xeb7>
lea    (%r15,%r8,1),%rdx
lea    (%rdi,%rdx,4),%rdx
movslq %esi,%rsi
mov    %r8,%rbp
lea    (%rdi,%rsi,4),%r8
lea    (%rsi,%rbp,1),%rbx
lea    (%rdi,%rbx,4),%r10
mov    -0x78(%rsp),%rbp
sub    %rbp,%rsi
lea    (%rdi,%rsi,4),%rsi
sub    %rbp,%rbx
lea    (%rdi,%rbx,4),%rbx
cmp    %r10,%r12
setb   %r10b
cmp    %rdx,%r8
setb   %r8b
cmp    %rbx,%r12
setb   %bl
cmp    %rdx,%rsi
setb   %sil
xor    %edx,%edx
test   %r8b,%r10b
jne    1fb2 <fibe2o_f+0xeb2>
and    %sil,%bl
mov    -0x80(%rsp),%r8
jne    1fb7 <fibe2o_f+0xeb7>
mov    %r8d,%edx
and    $0xfffffff8,%edx
movaps %xmm15,%xmm9
shufps $0x0,%xmm15,%xmm9
movaps %xmm1,%xmm11
shufps $0x0,%xmm1,%xmm11
lea    (%rdi,%r15,4),%rsi
add    $0x10,%rsi
lea    (%r11,%r11,4),%r8d
xor    %ebx,%ebx
movups -0x10(%rsi,%rbx,4),%xmm0
movups (%rsi,%rbx,4),%xmm4
lea    (%rax,%rbx,1),%ebp
movslq %ebp,%rbp
movups (%rdi,%rbp,4),%xmm6
movups 0x10(%rdi,%rbp,4),%xmm7
mulps  %xmm9,%xmm6
addps  %xmm0,%xmm6
mulps  %xmm9,%xmm7
addps  %xmm4,%xmm7
lea    (%r8,%rbx,1),%ebp
movslq %ebp,%rbp
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm4
mulps  %xmm11,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm11,%xmm4
addps  %xmm7,%xmm4
movups %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm4,(%rsi,%rbx,4)
add    $0x8,%rbx
cmp    %rbx,%rdx
jne    1f16 <fibe2o_f+0xe16>
mov    -0x80(%rsp),%r8
cmp    %r8,%rdx
jne    1fb7 <fibe2o_f+0xeb7>
jmp    1ff8 <fibe2o_f+0xef8>
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
mov    -0x68(%rsp),%r15
jmp    19d9 <fibe2o_f+0x8d9>
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
mov    -0x68(%rsp),%r15
jmp    1a47 <fibe2o_f+0x947>
mov    -0x70(%rsp),%r11
mov    -0x80(%rsp),%r8
jmp    1ab0 <fibe2o_f+0x9b0>
mov    -0x80(%rsp),%r8
lea    (%r11,%r11,4),%esi
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rdx,1),%ebp
movslq %ebp,%rbp
movss  (%rdi,%rbp,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%r12,%rdx,4),%xmm0
lea    (%rsi,%rdx,1),%ebp
movslq %ebp,%rbp
movss  (%rdi,%rbp,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1fc0 <fibe2o_f+0xec0>
mov    -0x78(%rsp),%rbx
cmpl   $0x8,-0x50(%rsp)
jle    242a <fibe2o_f+0x132a>
mov    -0x50(%rsp),%eax
mov    %rax,-0x60(%rsp)
lea    0x1(,%rbx,8),%rax
mov    %rax,-0x8(%rsp)
mov    -0x58(%rsp),%rax
and    $0x3,%eax
mov    %rax,-0x58(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
add    %rdi,%rax
addq   $0x1,(%rsp)
mov    %r11d,%edx
not    %edx
lea    (%rdx,%r11,8),%r8d
lea    -0x1(,%r11,8),%r12d
ff
mov    $0x8,%r15d
xor    %r13d,%r13d
jmp    20d4 <fibe2o_f+0xfd4>
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%rdi,%rbx,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%rdi,%r14,4),%xmm0
mov    %rbx,%rdx
mov    -0x78(%rsp),%rsi
sub    %rsi,%rdx
movss  0x4(%rdi,%rdx,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdi,%r14,4)
movss  (%rdi,%rbx,4),%xmm0
mov    %rsi,%rbx
mulss  %xmm15,%xmm0
addss  (%rdi,%r10,4),%xmm0
movss  (%rdi,%rdx,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdi,%r10,4)
add    $0x1,%r15
add    $0x1,%r13
add    -0x48(%rsp),%rax
add    %r11d,%r8d
add    %r11d,%r12d
cmp    -0x60(%rsp),%r15
je     242a <fibe2o_f+0x132a>
mov    %r15,%r10
imul   %rbx,%r10
movss  (%rdi,%r10,4),%xmm7
test   %ecx,%ecx
je     2130 <fibe2o_f+0x1030>
movaps %xmm7,%xmm5
addss  0xf30(%rip),%xmm5
movss  0x4(%rdi,%r10,4),%xmm4
addss  %xmm4,%xmm5
addss  0x8(%rdi,%r10,4),%xmm5
addss  0xc(%rdi,%r10,4),%xmm5
addss  0x10(%rdi,%r10,4),%xmm5
addss  0x14(%rdi,%r10,4),%xmm5
addss  0x18(%rdi,%r10,4),%xmm5
lea    0x1(%r10),%r14
addss  0x1c(%rdi,%r10,4),%xmm5
mulss  %xmm14,%xmm5
jmp    213e <fibe2o_f+0x103e>
lea    0x1(%r10),%r14
movss  0x4(%rdi,%r10,4),%xmm4
xorps  %xmm5,%xmm5
mov    -0x58(%rsp),%rdx
movaps %xmm10,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm13,%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,(%rdi,%r10,4)
mulss  %xmm8,%xmm7
mulss  %xmm13,%xmm4
subss  %xmm7,%xmm4
movaps %xmm12,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%r14,4)
test   %ecx,%ecx
je     21e5 <fibe2o_f+0x10e5>
xorps  %xmm5,%xmm5
cmp    %r11d,0x8(%rsp)
jge    21e0 <fibe2o_f+0x10e0>
xorps  %xmm5,%xmm5
test   %rdx,%rdx
je     2414 <fibe2o_f+0x1314>
mov    0x18(%rsp),%rsi
nopl   0x0(%rax)
addss  (%rax,%rsi,4),%xmm5
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    21a0 <fibe2o_f+0x10a0>
cmpq   $0x3,-0x38(%rsp)
jb     21e0 <fibe2o_f+0x10e0>
nopw   0x0(%rax,%rax,1)
addss  (%rax,%rsi,4),%xmm5
addss  0x4(%rax,%rsi,4),%xmm5
addss  0x8(%rax,%rsi,4),%xmm5
addss  0xc(%rax,%rsi,4),%xmm5
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    21c0 <fibe2o_f+0x10c0>
mulss  %xmm14,%xmm5
mov    %r11,%rdx
lea    (%r10,%rbx,1),%r11
cmp    $0x3,%edx
jl     22b0 <fibe2o_f+0x11b0>
mov    %r13,%rdx
imul   %rbx,%rdx
add    -0x8(%rsp),%rdx
movss  (%rdi,%rdx,4),%xmm7
cmpq   $0x0,-0x30(%rsp)
je     23ff <fibe2o_f+0x12ff>
mov    $0x2,%esi
nopw   0x0(%rax,%rax,1)
mulss  %xmm8,%xmm7
movss  (%rax,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm7,%xmm0
movss  -0x8(%rax,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rax,%rsi,4)
mulss  %xmm8,%xmm4
movss  0x4(%rax,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm4,%xmm0
movss  -0x4(%rax,%rsi,4),%xmm7
mulss  %xmm1,%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,0x4(%rax,%rsi,4)
lea    (%r9,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
cmp    $0x2,%rdx
jne    2220 <fibe2o_f+0x1120>
testb  $0x1,-0x80(%rsp)
je     22b0 <fibe2o_f+0x11b0>
add    %r10,%rsi
mulss  %xmm8,%xmm7
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm13,%xmm0
subss  %xmm7,%xmm0
movss  -0x8(%rdi,%rsi,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%rdi,%rsi,4)
movss  -0x8(%rdi,%r11,4),%xmm9
movss  -0x4(%rdi,%r11,4),%xmm7
movaps %xmm7,%xmm0
addss  %xmm9,%xmm0
cvtss2sd %xmm0,%xmm11
mulsd  0xd3c(%rip),%xmm11
movaps %xmm7,%xmm6
subss  %xmm9,%xmm6
movaps %xmm6,%xmm4
mulss  %xmm2,%xmm4
cvtss2sd %xmm4,%xmm4
movapd %xmm11,%xmm0
mulsd  -0x10(%rsp),%xmm0
addsd  %xmm4,%xmm0
xorps  %xmm4,%xmm4
cvtsd2ss %xmm0,%xmm4
mulss  %xmm3,%xmm6
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulsd  -0x18(%rsp),%xmm11
addsd  %xmm0,%xmm11
xorps  %xmm0,%xmm0
cvtsd2ss %xmm11,%xmm0
test   %ecx,%ecx
je     233c <fibe2o_f+0x123c>
movss  -0x28(%rsp),%xmm6
mulss  %xmm5,%xmm6
addss  %xmm6,%xmm4
movss  -0x20(%rsp),%xmm6
mulss  %xmm5,%xmm6
addss  %xmm6,%xmm0
mov    %r10,%rbx
sub    -0x78(%rsp),%rbx
movaps %xmm15,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm7,%xmm6
mulss  %xmm1,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,-0x4(%rdi,%r11,4)
mulss  %xmm15,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,-0x8(%rdi,%r11,4)
mov    -0x70(%rsp),%r11
cmp    $0x3,%r11d
jl     2060 <fibe2o_f+0xf60>
mov    %r12d,%esi
mov    %r8d,%ebp
mov    (%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mulss  %xmm15,%xmm0
addss  -0x4(%rax,%rdx,4),%xmm0
movss  0x4(%rax,%rdx,4),%xmm4
movaps %xmm1,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm0,%xmm6
movss  %xmm6,-0x4(%rax,%rdx,4)
movslq %esi,%rsi
movss  (%rdi,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  %xmm4,%xmm0
movslq %ebp,%rbp
movss  (%rdi,%rbp,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,0x4(%rax,%rdx,4)
add    $0xffffffff,%ebp
add    $0xffffffff,%esi
add    $0xffffffffffffffff,%rdx
jg     23a0 <fibe2o_f+0x12a0>
jmp    2060 <fibe2o_f+0xf60>
mov    $0x2,%esi
testb  $0x1,-0x80(%rsp)
jne    2287 <fibe2o_f+0x1187>
jmp    22b0 <fibe2o_f+0x11b0>
mov    0x18(%rsp),%rsi
cmpq   $0x3,-0x38(%rsp)
jae    21c0 <fibe2o_f+0x10c0>
jmp    21e0 <fibe2o_f+0x10e0>
test   %r11d,%r11d
jle    2670 <fibe2o_f+0x1570>
movsd  0x28(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm8
mov    -0x50(%rsp),%rsi
lea    -0x2(%rsi),%r8d
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mov    -0x70(%rsp),%rbp
imul   %ebp,%r8d
lea    -0x1(%rsi),%edx
addss  0xbba(%rip),%xmm0
imul   %ebp,%edx
cvttss2si %xmm0,%ebp
mov    %ebp,-0x58(%rsp)
movslq %ebp,%rax
movslq %r8d,%rbp
mov    %rbp,-0x30(%rsp)
movslq %edx,%r8
movslq %esi,%rdx
mov    %esi,%r9d
sub    %eax,%r9d
mov    %rax,%rsi
not    %rsi
mov    %rdx,(%rsp)
add    %rdx,%rsi
mov    %rsi,0x8(%rsp)
and    $0x3,%r9d
mov    %rax,-0x60(%rsp)
imul   %rbx,%rax
lea    (%rdi,%rax,4),%r15
mov    %r9,-0x38(%rsp)
neg    %r9
mov    %rbx,%r11
shl    $0x4,%r11
xor    %r10d,%r10d
mov    %rdi,%r14
jmp    2508 <fibe2o_f+0x1408>
xchg   %ax,%ax
movaps %xmm15,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm9,%xmm4
mulss  %xmm1,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rbp,4)
mulss  %xmm15,%xmm0
addss  (%rdi,%rsi,4),%xmm0
mulss  %xmm1,%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,(%rdi,%rsi,4)
add    $0x1,%r10
add    $0x4,%r15
add    $0x4,%r14
cmp    -0x80(%rsp),%r10
je     2670 <fibe2o_f+0x1570>
test   %ecx,%ecx
je     25d7 <fibe2o_f+0x14d7>
xorps  %xmm5,%xmm5
mov    -0x58(%rsp),%eax
cmp    -0x50(%rsp),%eax
jge    25d2 <fibe2o_f+0x14d2>
cmpq   $0x0,-0x38(%rsp)
je     2562 <fibe2o_f+0x1462>
xorps  %xmm5,%xmm5
mov    %r15,%rdx
xor    %esi,%esi
mov    -0x48(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
addss  (%rdx),%xmm5
add    $0xffffffffffffffff,%rsi
add    %rax,%rdx
cmp    %rsi,%r9
jne    2540 <fibe2o_f+0x1440>
mov    -0x60(%rsp),%rdx
sub    %rsi,%rdx
cmpq   $0x3,0x8(%rsp)
jae    2572 <fibe2o_f+0x1472>
jmp    25d2 <fibe2o_f+0x14d2>
xorps  %xmm5,%xmm5
mov    -0x60(%rsp),%rdx
cmpq   $0x3,0x8(%rsp)
jb     25d2 <fibe2o_f+0x14d2>
mov    (%rsp),%rsi
sub    %rdx,%rsi
lea    0x3(%rdx),%rbx
mov    -0x78(%rsp),%r13
imul   %r13,%rbx
lea    (%r14,%rbx,4),%rbp
lea    0x2(%rdx),%rbx
imul   %r13,%rbx
lea    (%r14,%rbx,4),%rbx
mov    %r13,%rax
imul   %rdx,%rax
lea    (%r14,%rax,4),%r12
add    $0x1,%rdx
imul   %r13,%rdx
lea    (%r14,%rdx,4),%rdx
xor    %r13d,%r13d
addss  (%r12,%r13,1),%xmm5
addss  (%rdx,%r13,1),%xmm5
addss  (%rbx,%r13,1),%xmm5
addss  0x0(%rbp,%r13,1),%xmm5
add    %r11,%r13
add    $0xfffffffffffffffc,%rsi
jne    25b0 <fibe2o_f+0x14b0>
mulss  %xmm8,%xmm5
lea    (%r10,%r8,1),%rbp
mov    -0x30(%rsp),%rax
lea    (%r10,%rax,1),%rsi
movss  (%rdi,%rbp,4),%xmm9
movss  (%rdi,%rsi,4),%xmm0
movaps %xmm9,%xmm7
addss  %xmm0,%xmm7
xorps  %xmm4,%xmm4
cvtss2sd %xmm7,%xmm4
mulsd  0xa0a(%rip),%xmm4
movaps %xmm9,%xmm6
subss  %xmm0,%xmm6
movaps %xmm6,%xmm0
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
movapd %xmm4,%xmm7
mulsd  -0x10(%rsp),%xmm7
addsd  %xmm0,%xmm7
cvtsd2ss %xmm7,%xmm7
mulss  %xmm3,%xmm6
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulsd  -0x18(%rsp),%xmm4
addsd  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
test   %ecx,%ecx
je     24c0 <fibe2o_f+0x13c0>
movss  -0x28(%rsp),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm4,%xmm7
movss  -0x20(%rsp),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm4,%xmm0
jmp    24c0 <fibe2o_f+0x13c0>
cmpl   $0x3,-0x50(%rsp)
mov    -0x80(%rsp),%rbx
jl     28c8 <fibe2o_f+0x17c8>
mov    -0x50(%rsp),%rax
lea    -0x3(%rax),%r15d
lea    -0x1(%rbx),%r8
mov    -0x78(%rsp),%rcx
mov    %rcx,%rdx
imul   %r15,%rdx
lea    (%rdx,%rbx,1),%rsi
mov    %rsi,-0x18(%rsp)
lea    0x1(%r15),%rsi
imul   %rcx,%rsi
lea    (%rsi,%rbx,1),%rcx
mov    %rcx,-0x28(%rsp)
lea    (%rdi,%rbx,4),%rcx
mov    %rcx,-0x30(%rsp)
mov    %ebx,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x38(%rsp)
movaps %xmm15,%xmm3
shufps $0x0,%xmm15,%xmm3
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
lea    (%rdi,%rdx,4),%rcx
add    $0x10,%rcx
negq   -0x48(%rsp)
lea    (%rdi,%rsi,4),%rbp
add    $0x10,%rbp
lea    -0x1(%rax),%r10d
mov    -0x70(%rsp),%rax
imul   %eax,%r10d
mov    %eax,%r9d
neg    %r9d
mov    %rsi,-0x20(%rsp)
lea    (%rdi,%rsi,4),%r11
mov    %rdx,-0x10(%rsp)
lea    (%rdi,%rdx,4),%r12
xor    %r13d,%r13d
mov    %r8,-0x58(%rsp)
mov    %r9,-0x60(%rsp)
jmp    2748 <fibe2o_f+0x1648>
nop
lea    -0x1(%r15),%rax
add    $0x1,%r13
mov    -0x48(%rsp),%rdx
add    %rdx,%rcx
add    %rdx,%rbp
add    %r9,%r10
add    %rdx,%r11
add    %rdx,%r12
test   %r15,%r15
mov    %rax,%r15
jle    28c8 <fibe2o_f+0x17c8>
cmpl   $0x0,-0x70(%rsp)
jle    2720 <fibe2o_f+0x1620>
mov    -0x70(%rsp),%rdx
cmp    $0x8,%edx
jae    2760 <fibe2o_f+0x1660>
xor    %esi,%esi
jmp    2890 <fibe2o_f+0x1790>
mov    %r13d,%eax
not    %eax
add    -0x50(%rsp),%eax
imul   %edx,%eax
lea    (%rax,%r8,1),%esi
cmp    %eax,%esi
jl     2879 <fibe2o_f+0x1779>
mov    %r8,%rsi
shr    $0x20,%rsi
mov    $0x0,%esi
jne    2890 <fibe2o_f+0x1790>
mov    %r13,%rsi
imul   -0x78(%rsp),%rsi
mov    -0x10(%rsp),%r9
sub    %rsi,%r9
mov    -0x18(%rsp),%rdx
sub    %rsi,%rdx
mov    -0x20(%rsp),%r8
sub    %rsi,%r8
mov    -0x28(%rsp),%r14
sub    %rsi,%r14
lea    (%rdi,%r9,4),%rsi
lea    (%rdi,%rdx,4),%rdx
lea    (%rdi,%r8,4),%r8
lea    (%rdi,%r14,4),%r9
cltq
lea    (%rdi,%rax,4),%r14
mov    -0x30(%rsp),%rbx
lea    (%rbx,%rax,4),%rax
cmp    %r9,%rsi
setb   %r9b
cmp    %rdx,%r8
setb   %r8b
cmp    %rax,%rsi
setb   %al
cmp    %rdx,%r14
setb   %dl
test   %r8b,%r9b
jne    287d <fibe2o_f+0x177d>
mov    $0x0,%esi
and    %dl,%al
mov    -0x80(%rsp),%rbx
mov    -0x58(%rsp),%r8
mov    -0x60(%rsp),%r9
jne    2890 <fibe2o_f+0x1790>
xor    %esi,%esi
mov    -0x38(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,4),%xmm0
movups (%rcx,%rsi,4),%xmm4
movups -0x10(%rbp,%rsi,4),%xmm5
movups 0x0(%rbp,%rsi,4),%xmm6
mulps  %xmm3,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm3,%xmm6
addps  %xmm4,%xmm6
lea    (%r10,%rsi,1),%eax
cltq
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm4
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movups %xmm0,-0x10(%rcx,%rsi,4)
movups %xmm4,(%rcx,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    2820 <fibe2o_f+0x1720>
mov    %rdx,%rsi
cmp    %rbx,%rdx
jne    2890 <fibe2o_f+0x1790>
jmp    2720 <fibe2o_f+0x1620>
xor    %esi,%esi
jmp    2890 <fibe2o_f+0x1790>
xor    %esi,%esi
mov    -0x80(%rsp),%rbx
mov    -0x58(%rsp),%r8
mov    -0x60(%rsp),%r9
xchg   %ax,%ax
movss  (%r11,%rsi,4),%xmm0
mulss  %xmm15,%xmm0
addss  (%r12,%rsi,4),%xmm0
lea    (%r10,%rsi,1),%eax
cltq
movss  (%rdi,%rax,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  %xmm4,(%r12,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    2890 <fibe2o_f+0x1790>
jmp    2720 <fibe2o_f+0x1620>
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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