void passf5(int ido, int l1, const float cc[], float ch[], const float wa1[],
            const float wa2[], const float wa3[], const float wa4[],
            int isign) {
  static const float tr11 = 0.309016994374947;
  static const float ti11 = 0.951056516295154;
  static const float tr12 = -0.809016994374947;
  static const float ti12 = 0.587785252292473;
  int i, k, ac, ah;
  float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3,
      ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
  if (ido == 2) {
    for (k = 1; k <= l1; ++k) {
      ac = (5 * k - 4) * ido + 1;
      ti5 = cc[ac] - cc[ac + 3 * ido];
      ti2 = cc[ac] + cc[ac + 3 * ido];
      ti4 = cc[ac + ido] - cc[ac + 2 * ido];
      ti3 = cc[ac + ido] + cc[ac + 2 * ido];
      tr5 = cc[ac - 1] - cc[ac + 3 * ido - 1];
      tr2 = cc[ac - 1] + cc[ac + 3 * ido - 1];
      tr4 = cc[ac + ido - 1] - cc[ac + 2 * ido - 1];
      tr3 = cc[ac + ido - 1] + cc[ac + 2 * ido - 1];
      ah = (k - 1) * ido;
      ch[ah] = cc[ac - ido - 1] + tr2 + tr3;
      ch[ah + 1] = cc[ac - ido] + ti2 + ti3;
      cr2 = cc[ac - ido - 1] + tr11 * tr2 + tr12 * tr3;
      ci2 = cc[ac - ido] + tr11 * ti2 + tr12 * ti3;
      cr3 = cc[ac - ido - 1] + tr12 * tr2 + tr11 * tr3;
      ci3 = cc[ac - ido] + tr12 * ti2 + tr11 * ti3;
      cr5 = isign * (ti11 * tr5 + ti12 * tr4);
      ci5 = isign * (ti11 * ti5 + ti12 * ti4);
      cr4 = isign * (ti12 * tr5 - ti11 * tr4);
      ci4 = isign * (ti12 * ti5 - ti11 * ti4);
      ch[ah + l1 * ido] = cr2 - ci5;
      ch[ah + 4 * l1 * ido] = cr2 + ci5;
      ch[ah + l1 * ido + 1] = ci2 + cr5;
      ch[ah + 2 * l1 * ido + 1] = ci3 + cr4;
      ch[ah + 2 * l1 * ido] = cr3 - ci4;
      ch[ah + 3 * l1 * ido] = cr3 + ci4;
      ch[ah + 3 * l1 * ido + 1] = ci3 - cr4;
      ch[ah + 4 * l1 * ido + 1] = ci2 - cr5;
    }
  } else {
    for (k = 1; k <= l1; k++) {
      for (i = 0; i < ido - 1; i += 2) {
        ac = i + 1 + (k * 5 - 4) * ido;
        ti5 = cc[ac] - cc[ac + 3 * ido];
        ti2 = cc[ac] + cc[ac + 3 * ido];
        ti4 = cc[ac + ido] - cc[ac + 2 * ido];
        ti3 = cc[ac + ido] + cc[ac + 2 * ido];
        tr5 = cc[ac - 1] - cc[ac + 3 * ido - 1];
        tr2 = cc[ac - 1] + cc[ac + 3 * ido - 1];
        tr4 = cc[ac + ido - 1] - cc[ac + 2 * ido - 1];
        tr3 = cc[ac + ido - 1] + cc[ac + 2 * ido - 1];
        ah = i + (k - 1) * ido;
        ch[ah] = cc[ac - ido - 1] + tr2 + tr3;
        ch[ah + 1] = cc[ac - ido] + ti2 + ti3;
        cr2 = cc[ac - ido - 1] + tr11 * tr2 + tr12 * tr3;
        ci2 = cc[ac - ido] + tr11 * ti2 + tr12 * ti3;
        cr3 = cc[ac - ido - 1] + tr12 * tr2 + tr11 * tr3;
        ci3 = cc[ac - ido] + tr12 * ti2 + tr11 * ti3;
        cr5 = isign * (ti11 * tr5 + ti12 * tr4);
        ci5 = isign * (ti11 * ti5 + ti12 * ti4);
        cr4 = isign * (ti12 * tr5 - ti11 * tr4);
        ci4 = isign * (ti12 * ti5 - ti11 * ti4);
        dr3 = cr3 - ci4;
        dr4 = cr3 + ci4;
        di3 = ci3 + cr4;
        di4 = ci3 - cr4;
        dr5 = cr2 + ci5;
        dr2 = cr2 - ci5;
        di5 = ci2 - cr5;
        di2 = ci2 + cr5;
        ch[ah + l1 * ido] = wa1[i] * dr2 - isign * wa1[i + 1] * di2;
        ch[ah + l1 * ido + 1] = wa1[i] * di2 + isign * wa1[i + 1] * dr2;
        ch[ah + 2 * l1 * ido] = wa2[i] * dr3 - isign * wa2[i + 1] * di3;
        ch[ah + 2 * l1 * ido + 1] = wa2[i] * di3 + isign * wa2[i + 1] * dr3;
        ch[ah + 3 * l1 * ido] = wa3[i] * dr4 - isign * wa3[i + 1] * di4;
        ch[ah + 3 * l1 * ido + 1] = wa3[i] * di4 + isign * wa3[i + 1] * dr4;
        ch[ah + 4 * l1 * ido] = wa4[i] * dr5 - isign * wa4[i + 1] * di5;
        ch[ah + 4 * l1 * ido + 1] = wa4[i] * di5 + isign * wa4[i + 1] * dr5;
      }
    }
  }
}


x86 assembly (clang, -O0):
<passf5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x2,-0x4(%rbp)
jne    1679 <passf5+0x579>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1674 <passf5+0x574>
imul   $0x5,-0x30(%rbp),%eax
sub    $0x4,%eax
imul   -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
imul   -0x4(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x8c(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  0xca3(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  0xc8f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm1
movss  0xc5f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  0xc4e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  0xc1c(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  0xc00(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm1
movss  0xbd8(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  0xbbf(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x98(%rbp),%xmm1
ff
movss  0xb95(%rip),%xmm2
mulss  -0x94(%rbp),%xmm2
ff
movss  0xb89(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
movss  0xb62(%rip),%xmm2
mulss  -0x74(%rbp),%xmm2
movss  0xb59(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x98(%rbp),%xmm1
ff
movss  0xb33(%rip),%xmm2
mulss  -0x94(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  0xb12(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
movss  0xaf3(%rip),%xmm2
mulss  -0x74(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  0xad5(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    113a <passf5+0x3a>
jmp    1e12 <passf5+0xd12>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1e0d <passf5+0xd0d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1dfa <passf5+0xcfa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
imul   $0x5,-0x30(%rbp),%ecx
sub    $0x4,%ecx
imul   -0x4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x3,-0x4(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x8c(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  0x73b(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  0x727(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm1
movss  0x6f7(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  0x6e6(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
movss  0x6b4(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
movss  0x698(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm1
movss  0x670(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  0x657(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x98(%rbp),%xmm1
ff
movss  0x62d(%rip),%xmm2
mulss  -0x94(%rbp),%xmm2
ff
movss  0x621(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
movss  0x5fa(%rip),%xmm2
mulss  -0x74(%rbp),%xmm2
movss  0x5f1(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x98(%rbp),%xmm1
ff
movss  0x5cb(%rip),%xmm2
mulss  -0x94(%rbp),%xmm2
ff
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  0x5aa(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
cvtsi2ssl 0x20(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
movss  0x58b(%rip),%xmm2
mulss  -0x74(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  0x56d(%rip),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x88(%rbp),%xmm2
ff
cvtsi2ssl 0x20(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x58(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x7c(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x80(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x50(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x84(%rbp),%xmm2
ff
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x54(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
cvtsi2ssl 0x20(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1693 <passf5+0x593>
jmp    1dff <passf5+0xcff>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1680 <passf5+0x580>
jmp    1e12 <passf5+0xd12>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<passf5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x48(%rsp),%eax
cmp    $0x2,%edi
jne    13bd <passf5+0x2bd>
test   %esi,%esi
jle    17f0 <passf5+0x6f0>
mov    %rsi,%r12
cvtsi2ss %eax,%xmm13
lea    (%rsi,%rsi,1),%r11d
lea    0x0(,%rsi,8),%r9d
lea    (%r11,%r11,2),%r14d
mov    %r12d,%esi
shl    $0x2,%r12d
add    %rsi,%rsi
lea    (%rsi,%rsi,4),%r8
add    $0xa,%r8
xor    %ebx,%ebx
movabs $0x100000000,%r15
mov    $0xa,%esi
movabs $0x200000000,%r10
movss  0xe97(%rip),%xmm12
nopl   (%rax)
lea    -0x8(%rsi),%eax
lea    -0x7(%rsi),%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm2
lea    -0x1(%rsi),%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
movaps %xmm2,%xmm10
subss  %xmm0,%xmm10
lea    -0x5(%rsi),%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm7
addss  %xmm0,%xmm2
lea    -0x3(%rsi),%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm0
movaps %xmm7,%xmm14
subss  %xmm0,%xmm14
cltq
movss  (%rdx,%rax,4),%xmm4
lea    -0x2(%rsi),%eax
addss  %xmm0,%xmm7
cltq
movss  (%rdx,%rax,4),%xmm0
movaps %xmm4,%xmm1
lea    -0x6(%rsi),%eax
subss  %xmm0,%xmm1
cltq
movss  (%rdx,%rax,4),%xmm5
lea    -0x4(%rsi),%eax
addss  %xmm0,%xmm4
cltq
movss  (%rdx,%rax,4),%xmm0
movaps %xmm5,%xmm15
lea    -0x9(%rsi),%eax
subss  %xmm0,%xmm15
lea    -0xa(%rsi),%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm3
addss  %xmm0,%xmm5
addss  %xmm4,%xmm3
addss  %xmm5,%xmm3
movslq %ebx,%rbx
movss  %xmm3,(%rcx,%rbx,4)
cltq
movss  (%rdx,%rax,4),%xmm0
addss  %xmm2,%xmm0
addss  %xmm7,%xmm0
mov    %r15,%rbp
sar    $0x1e,%rbp
movss  %xmm0,(%rcx,%rbp,1)
movaps %xmm4,%xmm3
movss  0xdc5(%rip),%xmm11
mulss  %xmm11,%xmm3
movss  (%rdx,%rdi,4),%xmm8
addss  %xmm8,%xmm3
movaps %xmm5,%xmm0
mulss  %xmm12,%xmm0
movss  (%rdx,%rax,4),%xmm9
movaps %xmm2,%xmm6
addss  %xmm3,%xmm0
mulss  %xmm11,%xmm6
addss  %xmm9,%xmm6
movaps %xmm7,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm6,%xmm3
mulss  %xmm12,%xmm4
addss  %xmm8,%xmm4
mulss  %xmm11,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm12,%xmm2
addss  %xmm9,%xmm2
movaps %xmm15,%xmm6
movss  0xd68(%rip),%xmm9
mulss  %xmm9,%xmm6
movaps %xmm1,%xmm8
mulss  %xmm11,%xmm7
movss  0xd55(%rip),%xmm11
mulss  %xmm11,%xmm8
addss  %xmm6,%xmm8
movaps %xmm14,%xmm4
mulss  %xmm9,%xmm4
addss  %xmm2,%xmm7
movaps %xmm10,%xmm6
mulss  %xmm11,%xmm6
addss  %xmm4,%xmm6
movss  0xd2d(%rip),%xmm2
mulss  %xmm2,%xmm15
mulss  %xmm9,%xmm1
addss  %xmm15,%xmm1
mulss  %xmm2,%xmm14
mulss  %xmm9,%xmm10
mulss  %xmm13,%xmm6
addss  %xmm14,%xmm10
movaps %xmm0,%xmm2
lea    (%r11,%rbx,1),%eax
cltq
subss  %xmm6,%xmm2
movss  %xmm2,(%rcx,%rax,4)
addss  %xmm0,%xmm6
mulss  %xmm13,%xmm8
mulss  %xmm13,%xmm1
mulss  %xmm13,%xmm10
lea    (%r9,%rbx,1),%eax
cltq
movss  %xmm6,(%rcx,%rax,4)
movaps %xmm8,%xmm0
addss  %xmm3,%xmm0
lea    0x1(%r11,%rbx,1),%eax
cltq
movss  %xmm0,(%rcx,%rax,4)
movaps %xmm1,%xmm0
lea    (%r12,%rbx,1),%eax
lea    0x1(%r12,%rbx,1),%edi
movslq %edi,%rdi
addss  %xmm7,%xmm0
movss  %xmm0,(%rcx,%rdi,4)
movaps %xmm5,%xmm0
subss  %xmm10,%xmm0
cltq
movss  %xmm0,(%rcx,%rax,4)
addss  %xmm5,%xmm10
lea    (%r14,%rbx,1),%eax
cltq
movss  %xmm10,(%rcx,%rax,4)
subss  %xmm1,%xmm7
lea    0x1(%r14,%rbx,1),%eax
cltq
movss  %xmm7,(%rcx,%rax,4)
subss  %xmm8,%xmm3
lea    (%r9,%rbx,1),%eax
add    $0x1,%eax
cltq
movss  %xmm3,(%rcx,%rax,4)
add    $0x2,%ebx
add    %r10,%r15
add    $0xa,%rsi
cmp    %rsi,%r8
jne    1170 <passf5+0x70>
jmp    17f0 <passf5+0x6f0>
mov    %rdi,-0x28(%rsp)
test   %esi,%esi
jle    17f0 <passf5+0x6f0>
mov    %rsi,%rbx
mov    %rcx,%r11
mov    0x40(%rsp),%rcx
mov    0x38(%rsp),%r15
mov    -0x28(%rsp),%rsi
lea    -0x1(%rsi),%r12d
lea    (%rsi,%rsi,2),%edi
lea    (%rsi,%rsi,1),%r10d
cvtsi2ss %eax,%xmm11
mov    %ebx,%eax
imul   %esi,%eax
lea    (%rax,%rax,1),%r13d
movslq %edi,%rbp
mov    %rbp,-0x30(%rsp)
imul   %ebx,%edi
movslq %esi,%r14
movslq %r10d,%rsi
movslq %eax,%rbp
mov    %rbp,-0x38(%rsp)
shl    $0x2,%eax
movslq %r13d,%r10
movslq %edi,%r13
cltq
movslq %r12d,%rbp
mov    %rbp,-0x8(%rsp)
add    $0x1,%ebx
mov    %rbx,-0x10(%rsp)
lea    (%r11,%rax,4),%r12
add    $0x4,%r12
lea    0x0(,%r14,4),%rdi
lea    0x4(%r11,%r13,4),%r13
lea    (%r11,%r10,4),%r10
add    $0x4,%r10
mov    -0x38(%rsp),%rax
lea    (%r11,%rax,4),%rax
add    $0x4,%rax
add    $0x4,%r11
lea    (%rdx,%r14,4),%rbp
add    $0x4,%rbp
mov    %rdi,-0x18(%rsp)
lea    (%rdi,%rdi,4),%rdi
mov    %rdi,-0x20(%rsp)
lea    0x4(%rdx),%rdi
add    %r14,%rsi
lea    (%rdx,%rsi,4),%rsi
add    $0x4,%rsi
mov    -0x30(%rsp),%rbx
add    %r14,%rbx
lea    (%rdx,%r14,8),%r14
add    $0x4,%r14
lea    0x4(%rdx,%rbx,4),%rdx
mov    $0x1,%ebx
mov    %rbx,-0x38(%rsp)
movss  0xb5d(%rip),%xmm12
jmp    1500 <passf5+0x400>
nopl   0x0(%rax)
mov    -0x38(%rsp),%r11
add    $0x1,%r11
mov    %rbx,-0x30(%rsp)
mov    -0x18(%rsp),%rbx
add    %rbx,%r12
add    %rbx,%r13
add    %rbx,%r10
add    %rbx,%rax
add    %rbx,-0x30(%rsp)
mov    -0x20(%rsp),%rbx
add    %rbx,%rbp
add    %rbx,%rdi
add    %rbx,%rsi
add    %rbx,%r14
add    %rbx,%rdx
mov    -0x10(%rsp),%rbx
mov    %r11,-0x38(%rsp)
cmp    %rbx,%r11
mov    -0x30(%rsp),%r11
je     17f0 <passf5+0x6f0>
cmpl   $0x2,-0x28(%rsp)
mov    %r11,%rbx
jl     14b0 <passf5+0x3b0>
xor    %r11d,%r11d
nopl   (%rax)
movss  -0x4(%rbp,%r11,4),%xmm5
movss  0x0(%rbp,%r11,4),%xmm7
movss  -0x4(%rdx,%r11,4),%xmm0
movss  (%rdx,%r11,4),%xmm1
movaps %xmm7,%xmm8
subss  %xmm1,%xmm8
addss  %xmm1,%xmm7
movss  -0x4(%r14,%r11,4),%xmm4
movss  (%r14,%r11,4),%xmm6
movss  -0x4(%rsi,%r11,4),%xmm1
movss  (%rsi,%r11,4),%xmm2
movaps %xmm6,%xmm14
subss  %xmm2,%xmm14
addss  %xmm2,%xmm6
movaps %xmm5,%xmm2
subss  %xmm0,%xmm2
addss  %xmm0,%xmm5
movaps %xmm4,%xmm15
subss  %xmm1,%xmm15
addss  %xmm1,%xmm4
movss  -0x4(%rdi,%r11,4),%xmm0
addss  %xmm5,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x4(%rbx,%r11,4)
movss  (%rdi,%r11,4),%xmm0
addss  %xmm7,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rbx,%r11,4)
movaps %xmm5,%xmm0
movss  0xa54(%rip),%xmm1
mulss  %xmm1,%xmm0
movaps %xmm11,%xmm13
movaps %xmm1,%xmm11
movss  -0x4(%rdi,%r11,4),%xmm3
movss  (%rdi,%r11,4),%xmm10
addss  %xmm3,%xmm0
movaps %xmm4,%xmm1
mulss  %xmm12,%xmm1
addss  %xmm0,%xmm1
movaps %xmm7,%xmm0
mulss  %xmm11,%xmm0
addss  %xmm10,%xmm0
movaps %xmm6,%xmm9
mulss  %xmm12,%xmm9
addss  %xmm0,%xmm9
mulss  %xmm12,%xmm5
addss  %xmm3,%xmm5
movaps %xmm11,%xmm3
movaps %xmm13,%xmm11
movss  0xa02(%rip),%xmm13
mulss  %xmm3,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm12,%xmm7
addss  %xmm10,%xmm7
movss  0x9e3(%rip),%xmm10
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movaps %xmm15,%xmm0
mulss  %xmm10,%xmm0
movaps %xmm2,%xmm7
mulss  %xmm13,%xmm7
addss  %xmm0,%xmm7
movaps %xmm14,%xmm5
mulss  %xmm10,%xmm5
movaps %xmm8,%xmm0
mulss  %xmm13,%xmm0
movss  0x9b4(%rip),%xmm3
addss  %xmm5,%xmm0
mulss  %xmm11,%xmm7
mulss  %xmm11,%xmm0
mulss  %xmm3,%xmm15
mulss  %xmm10,%xmm2
addss  %xmm15,%xmm2
mulss  %xmm11,%xmm2
mulss  %xmm3,%xmm14
mulss  %xmm10,%xmm8
addss  %xmm14,%xmm8
mulss  %xmm11,%xmm8
movaps %xmm4,%xmm14
subss  %xmm8,%xmm14
addss  %xmm4,%xmm8
movaps %xmm2,%xmm5
addss  %xmm6,%xmm5
subss  %xmm2,%xmm6
movaps %xmm0,%xmm4
addss  %xmm1,%xmm4
subss  %xmm0,%xmm1
movaps %xmm9,%xmm2
subss  %xmm7,%xmm2
addss  %xmm9,%xmm7
movss  0x4(%r8,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm7,%xmm0
movss  (%r8,%r11,4),%xmm3
mulss  %xmm1,%xmm3
subss  %xmm0,%xmm3
movss  %xmm3,-0x4(%rax,%r11,4)
movss  0x4(%r8,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm1,%xmm0
mulss  (%r8,%r11,4),%xmm7
addss  %xmm0,%xmm7
movss  %xmm7,(%rax,%r11,4)
movss  0x4(%r9,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm5,%xmm0
movss  (%r9,%r11,4),%xmm1
mulss  %xmm14,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r10,%r11,4)
movss  0x4(%r9,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm14,%xmm0
mulss  (%r9,%r11,4),%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,(%r10,%r11,4)
movss  0x4(%r15,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm6,%xmm0
movss  (%r15,%r11,4),%xmm1
mulss  %xmm8,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r13,%r11,4)
movss  0x4(%r15,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm8,%xmm0
mulss  (%r15,%r11,4),%xmm6
addss  %xmm0,%xmm6
movss  %xmm6,0x0(%r13,%r11,4)
movss  0x4(%rcx,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm2,%xmm0
movss  (%rcx,%r11,4),%xmm1
mulss  %xmm4,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r12,%r11,4)
movss  0x4(%rcx,%r11,4),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm4,%xmm0
mulss  (%rcx,%r11,4),%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,(%r12,%r11,4)
add    $0x2,%r11
cmp    -0x8(%rsp),%r11
jl     1510 <passf5+0x410>
jmp    14b0 <passf5+0x3b0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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