void radf5(int ido, int l1, const float cc[], float ch[], const float wa1[],
           const float wa2[], const float wa3[], const float wa4[]) {
  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, ic;
  float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5,
      cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5;
  for (k = 0; k < l1; k++) {
    cr2 = cc[(k + 4 * l1) * ido] + cc[(k + l1) * ido];
    ci5 = cc[(k + 4 * l1) * ido] - cc[(k + l1) * ido];
    cr3 = cc[(k + 3 * l1) * ido] + cc[(k + 2 * l1) * ido];
    ci4 = cc[(k + 3 * l1) * ido] - cc[(k + 2 * l1) * ido];
    ch[5 * k * ido] = cc[k * ido] + cr2 + cr3;
    ch[ido - 1 + (5 * k + 1) * ido] = cc[k * ido] + tr11 * cr2 + tr12 * cr3;
    ch[(5 * k + 2) * ido] = ti11 * ci5 + ti12 * ci4;
    ch[ido - 1 + (5 * k + 3) * ido] = cc[k * ido] + tr12 * cr2 + tr11 * cr3;
    ch[(5 * k + 4) * ido] = ti12 * ci5 - ti11 * ci4;
  }
  if (ido == 1)
    return;
  for (k = 0; k < l1; ++k) {
    for (i = 2; i < ido; i += 2) {
      ic = ido - i;
      dr2 = wa1[i - 2] * cc[i - 1 + (k + l1) * ido] +
            wa1[i - 1] * cc[i + (k + l1) * ido];
      di2 = wa1[i - 2] * cc[i + (k + l1) * ido] -
            wa1[i - 1] * cc[i - 1 + (k + l1) * ido];
      dr3 = wa2[i - 2] * cc[i - 1 + (k + 2 * l1) * ido] +
            wa2[i - 1] * cc[i + (k + 2 * l1) * ido];
      di3 = wa2[i - 2] * cc[i + (k + 2 * l1) * ido] -
            wa2[i - 1] * cc[i - 1 + (k + 2 * l1) * ido];
      dr4 = wa3[i - 2] * cc[i - 1 + (k + 3 * l1) * ido] +
            wa3[i - 1] * cc[i + (k + 3 * l1) * ido];
      di4 = wa3[i - 2] * cc[i + (k + 3 * l1) * ido] -
            wa3[i - 1] * cc[i - 1 + (k + 3 * l1) * ido];
      dr5 = wa4[i - 2] * cc[i - 1 + (k + 4 * l1) * ido] +
            wa4[i - 1] * cc[i + (k + 4 * l1) * ido];
      di5 = wa4[i - 2] * cc[i + (k + 4 * l1) * ido] -
            wa4[i - 1] * cc[i - 1 + (k + 4 * l1) * ido];
      cr2 = dr2 + dr5;
      ci5 = dr5 - dr2;
      cr5 = di2 - di5;
      ci2 = di2 + di5;
      cr3 = dr3 + dr4;
      ci4 = dr4 - dr3;
      cr4 = di3 - di4;
      ci3 = di3 + di4;
      ch[i - 1 + 5 * k * ido] = cc[i - 1 + k * ido] + cr2 + cr3;
      ch[i + 5 * k * ido] = cc[i + k * ido] + ci2 + ci3;
      tr2 = cc[i - 1 + k * ido] + tr11 * cr2 + tr12 * cr3;
      ti2 = cc[i + k * ido] + tr11 * ci2 + tr12 * ci3;
      tr3 = cc[i - 1 + k * ido] + tr12 * cr2 + tr11 * cr3;
      ti3 = cc[i + k * ido] + tr12 * ci2 + tr11 * ci3;
      tr5 = ti11 * cr5 + ti12 * cr4;
      ti5 = ti11 * ci5 + ti12 * ci4;
      tr4 = ti12 * cr5 - ti11 * cr4;
      ti4 = ti12 * ci5 - ti11 * ci4;
      ch[i - 1 + (5 * k + 2) * ido] = tr2 + tr5;
      ch[ic - 1 + (5 * k + 1) * ido] = tr2 - tr5;
      ch[i + (5 * k + 2) * ido] = ti2 + ti5;
      ch[ic + (5 * k + 1) * ido] = ti5 - ti2;
      ch[i - 1 + (5 * k + 4) * ido] = tr3 + tr4;
      ch[ic - 1 + (5 * k + 3) * ido] = tr3 - tr4;
      ch[i + (5 * k + 4) * ido] = ti3 + ti4;
      ch[ic + (5 * k + 3) * ido] = ti4 - ti3;
    }
  }
}


x86 assembly (clang, -O0):
<radf5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
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)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    138d <radf5+0x28d>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x58(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm1
movss  0xda0(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  0xd8f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  0xd4f(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
movss  0xd46(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm1
movss  0xd0f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  0xcf6(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
movss  0xcbe(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xca0(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
add    $0x4,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    112d <radf5+0x2d>
cmpl   $0x1,-0x4(%rbp)
jne    139c <radf5+0x29c>
jmp    1bd9 <radf5+0xad9>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1bd9 <radf5+0xad9>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bc6 <radf5+0xac6>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x8(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   $0x3,-0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   $0x3,-0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   $0x3,-0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   $0x3,-0x8(%rbp),%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x2,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x2,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x2,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%esi
shl    $0x2,%esi
add    %esi,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x6c(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x68(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x48(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x58(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x38(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm1
movss  0x769(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  0x758(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm1
movss  0x71f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  0x70e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x58(%rbp),%xmm1
movss  0x6d9(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  0x6c0(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm1
movss  0x68f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
movss  0x676(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x70(%rbp),%xmm0
movss  0x654(%rip),%xmm1
mulss  -0x74(%rbp),%xmm1
movss  0x64b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  0x62a(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
movss  0x621(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x70(%rbp),%xmm0
movss  0x607(%rip),%xmm1
mulss  -0x74(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x5e9(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  0x5d0(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x5b2(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x4,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x4,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    13b6 <radf5+0x2b6>
jmp    1bcb <radf5+0xacb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13a3 <radf5+0x2a3>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radf5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,-0x64(%rsp)
test   %esi,%esi
jle    169a <radf5+0x59a>
lea    0x0(,%rsi,4),%eax
lea    (%rsi,%rsi,2),%ebp
lea    (%rsi,%rsi,1),%edi
movslq %eax,%r10
movslq -0x64(%rsp),%r13
movslq %ebp,%r14
movslq %edi,%rbx
mov    %rsi,-0x58(%rsp)
mov    %esi,%edi
mov    %r13,%r11
shl    $0x4,%r11
lea    0x0(,%r13,4),%rax
mov    %rax,-0x48(%rsp)
lea    (%rax,%rax,4),%rax
mov    %rax,-0x50(%rsp)
lea    0x0(%r13,%r13,2),%rax
lea    -0x4(,%r13,4),%rsi
ff
lea    (%rsi,%rax,4),%r15
lea    -0x1(%r13,%r13,1),%r12
mov    %r13,%rbp
mov    %rbx,%rax
mov    %rbx,-0x30(%rsp)
imul   %rbx,%rbp
imul   %r13,%r14
mov    %r13,%rax
imul   %rdi,%rax
mov    %r13,%rbx
mov    %r10,%rsi
mov    %r10,-0x28(%rsp)
imul   %r10,%rbx
movss  0xe63(%rip),%xmm8
movss  0xe5e(%rip),%xmm10
movss  0xe5a(%rip),%xmm7
movss  0xe55(%rip),%xmm9
movss  0xe51(%rip),%xmm6
mov    %rdi,%rsi
mov    %rdi,-0x40(%rsp)
mov    %rdx,%r10
mov    %rcx,%rsi
nopl   (%rax)
movss  (%r10,%rbx,4),%xmm0
movss  (%r10,%rax,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
subss  %xmm1,%xmm0
movss  (%r10,%r14,4),%xmm1
movss  (%r10,%rbp,4),%xmm4
movaps %xmm1,%xmm3
addss  %xmm4,%xmm3
subss  %xmm4,%xmm1
movss  (%r10),%xmm4
addss  %xmm2,%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,(%rsi)
movaps %xmm2,%xmm4
mulss  %xmm8,%xmm4
addss  (%r10),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm10,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%rsi,%r12,4)
movaps %xmm1,%xmm4
mulss  %xmm7,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm4,%xmm5
movss  %xmm5,(%rsi,%r13,8)
mulss  %xmm10,%xmm2
addss  (%r10),%xmm2
mulss  %xmm8,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%rsi,%r15,1)
mulss  %xmm6,%xmm1
mulss  %xmm7,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%r11,1)
add    -0x50(%rsp),%rsi
add    -0x48(%rsp),%r10
add    $0xffffffffffffffff,%rdi
jne    11d0 <radf5+0xd0>
cmpl   $0x1,-0x64(%rsp)
mov    -0x58(%rsp),%rax
je     169a <radf5+0x59a>
test   %eax,%eax
jle    169a <radf5+0x59a>
mov    %r13,%r14
lea    (%rax,%rax,2),%eax
cltq
mov    %rax,-0x38(%rsp)
xor    %eax,%eax
mov    %rax,-0x60(%rsp)
movss  0xd45(%rip),%xmm11
movss  0xd40(%rip),%xmm10
jmp    12ec <radf5+0x1ec>
cs nopw 0x0(%rax,%rax,1)
mov    -0x60(%rsp),%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,-0x60(%rsp)
cmp    -0x40(%rsp),%rsi
je     169a <radf5+0x59a>
cmpl   $0x3,-0x64(%rsp)
mov    0x40(%rsp),%rdi
mov    0x38(%rsp),%r11
jl     12d0 <radf5+0x1d0>
mov    -0x40(%rsp),%rax
mov    -0x60(%rsp),%rsi
add    %rsi,%rax
imul   %r14,%rax
mov    %rax,-0x48(%rsp)
mov    -0x30(%rsp),%rax
add    %rsi,%rax
imul   %r14,%rax
mov    %rax,-0x50(%rsp)
mov    -0x38(%rsp),%rax
add    %rsi,%rax
imul   %r14,%rax
mov    %rax,-0x58(%rsp)
mov    -0x28(%rsp),%rax
add    %rsi,%rax
imul   %r14,%rax
mov    %rax,-0x8(%rsp)
mov    %rsi,%rax
imul   %r14,%rax
mov    %rax,-0x10(%rsp)
lea    (%rsi,%rsi,4),%rax
imul   %r14,%rax
mov    %rax,-0x18(%rsp)
lea    (%rsi,%rsi,4),%rax
add    $0x2,%rax
imul   %r14,%rax
mov    %rax,-0x20(%rsp)
lea    (%rsi,%rsi,4),%r10
add    $0x1,%r10
imul   %r14,%r10
lea    (%rsi,%rsi,4),%r13
add    $0x4,%r13
imul   %r14,%r13
lea    (%rsi,%rsi,4),%r12
add    $0x3,%r12
imul   %r14,%r12
mov    $0x2,%ebx
nopl   0x0(%rax)
mov    %r9,%rax
mov    -0x48(%rsp),%rbp
lea    (%rbx,%rbp,1),%r9
add    $0xffffffffffffffff,%r9
movss  -0x8(%r8,%rbx,4),%xmm4
movss  -0x4(%r8,%rbx,4),%xmm1
mov    %r8,%rsi
lea    (%rbx,%rbp,1),%r8
movss  (%rdx,%r9,4),%xmm15
mov    %rax,%r9
movss  (%rdx,%r8,4),%xmm3
mov    %rsi,%r8
movaps %xmm4,%xmm13
mulss  %xmm15,%xmm13
mulss  %xmm1,%xmm15
movaps %xmm1,%xmm6
mulss  %xmm3,%xmm6
mov    -0x50(%rsp),%rsi
lea    -0x1(%rbx,%rsi,1),%rax
movss  (%rdx,%rax,4),%xmm1
movss  -0x8(%r9,%rbx,4),%xmm2
mulss  %xmm3,%xmm4
movss  -0x4(%r9,%rbx,4),%xmm3
lea    (%rbx,%rsi,1),%rax
movss  (%rdx,%rax,4),%xmm5
movaps %xmm2,%xmm7
mulss  %xmm1,%xmm7
mulss  %xmm3,%xmm1
mulss  %xmm5,%xmm3
mov    -0x58(%rsp),%rsi
lea    -0x1(%rbx,%rsi,1),%rax
mulss  %xmm5,%xmm2
movss  (%rdx,%rax,4),%xmm0
movss  -0x8(%r11,%rbx,4),%xmm5
movss  -0x4(%r11,%rbx,4),%xmm8
addss  %xmm6,%xmm13
lea    (%rbx,%rsi,1),%rax
movss  (%rdx,%rax,4),%xmm6
movaps %xmm5,%xmm14
mulss  %xmm0,%xmm14
subss  %xmm15,%xmm4
mulss  %xmm8,%xmm0
mulss  %xmm6,%xmm8
mulss  %xmm6,%xmm5
addss  %xmm3,%xmm7
mov    -0x8(%rsp),%rsi
lea    -0x1(%rbx,%rsi,1),%rax
movss  (%rdx,%rax,4),%xmm3
movss  -0x8(%rdi,%rbx,4),%xmm6
subss  %xmm1,%xmm2
movss  -0x4(%rdi,%rbx,4),%xmm15
lea    (%rbx,%rsi,1),%rax
movaps %xmm9,%xmm12
movss  (%rdx,%rax,4),%xmm9
movaps %xmm6,%xmm1
addss  %xmm8,%xmm14
mulss  %xmm3,%xmm1
mulss  %xmm15,%xmm3
mulss  %xmm9,%xmm15
subss  %xmm0,%xmm5
addss  %xmm15,%xmm1
mulss  %xmm9,%xmm6
subss  %xmm3,%xmm6
movaps %xmm13,%xmm0
addss  %xmm1,%xmm0
movaps %xmm4,%xmm15
subss  %xmm6,%xmm15
addss  %xmm4,%xmm6
movaps %xmm7,%xmm4
mov    -0x10(%rsp),%rsi
lea    -0x1(%rbx,%rsi,1),%rax
addss  %xmm14,%xmm4
movaps %xmm2,%xmm8
movss  (%rdx,%rax,4),%xmm3
addss  %xmm0,%xmm3
addss  %xmm4,%xmm3
subss  %xmm5,%xmm8
mov    -0x18(%rsp),%r15
lea    -0x1(%rbx,%r15,1),%rbp
movss  %xmm3,(%rcx,%rbp,4)
lea    (%rbx,%rsi,1),%rbp
addss  %xmm2,%xmm5
movss  (%rdx,%rbp,4),%xmm2
addss  %xmm6,%xmm2
addss  %xmm5,%xmm2
lea    (%rbx,%r15,1),%rsi
movss  %xmm2,(%rcx,%rsi,4)
subss  %xmm13,%xmm1
subss  %xmm7,%xmm14
movaps %xmm0,%xmm3
movss  (%rdx,%rax,4),%xmm9
mulss  %xmm11,%xmm3
addss  %xmm9,%xmm3
movaps %xmm4,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm3,%xmm2
movss  (%rdx,%rbp,4),%xmm7
movaps %xmm6,%xmm3
mulss  %xmm11,%xmm3
movaps %xmm5,%xmm13
mulss  %xmm10,%xmm13
addss  %xmm7,%xmm3
addss  %xmm3,%xmm13
mulss  %xmm10,%xmm0
addss  %xmm9,%xmm0
movaps %xmm12,%xmm9
movss  0xa75(%rip),%xmm12
mulss  %xmm11,%xmm4
mulss  %xmm10,%xmm6
addss  %xmm7,%xmm6
movss  0xa67(%rip),%xmm7
mulss  %xmm11,%xmm5
movaps %xmm8,%xmm3
addss  %xmm0,%xmm4
mulss  %xmm12,%xmm3
movaps %xmm15,%xmm0
mulss  %xmm9,%xmm0
addss  %xmm3,%xmm0
movaps %xmm14,%xmm3
addss  %xmm6,%xmm5
mulss  %xmm12,%xmm3
movaps %xmm1,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm3,%xmm6
mulss  %xmm7,%xmm8
mulss  %xmm12,%xmm15
addss  %xmm8,%xmm15
mulss  %xmm7,%xmm14
mulss  %xmm12,%xmm1
addss  %xmm14,%xmm1
movaps %xmm0,%xmm3
addss  %xmm2,%xmm3
mov    -0x20(%rsp),%rbp
lea    -0x1(%rbx,%rbp,1),%rax
movss  %xmm3,(%rcx,%rax,4)
subss  %xmm0,%xmm2
mov    %r14,%rax
sub    %rbx,%rax
lea    (%rax,%r10,1),%rsi
add    $0xffffffffffffffff,%rsi
movss  %xmm2,(%rcx,%rsi,4)
movaps %xmm6,%xmm0
addss  %xmm13,%xmm0
subss  %xmm13,%xmm6
lea    (%rbx,%rbp,1),%rsi
movss  %xmm0,(%rcx,%rsi,4)
lea    (%rax,%r10,1),%rsi
movss  %xmm6,(%rcx,%rsi,4)
movaps %xmm15,%xmm0
lea    -0x1(%rbx,%r13,1),%rsi
addss  %xmm4,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
subss  %xmm15,%xmm4
lea    -0x1(%rax,%r12,1),%rsi
movss  %xmm4,(%rcx,%rsi,4)
movaps %xmm1,%xmm0
addss  %xmm5,%xmm0
subss  %xmm5,%xmm1
lea    (%rbx,%r13,1),%rsi
movss  %xmm0,(%rcx,%rsi,4)
add    %r12,%rax
movss  %xmm1,(%rcx,%rax,4)
add    $0x2,%rbx
cmp    %r14,%rbx
jl     13a0 <radf5+0x2a0>
jmp    12d0 <radf5+0x1d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @radf5(i32 %0, i32 %1, float* nocapture %2, float* nocapture writeonly %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7) {
%9 = icmp sgt i32 %1, 0
br i1 %9, label %10, label %249
10: ; preds = %8
%11 = shl nsw i32 %1, 2
%12 = mul nsw i32 %1, 3
%13 = shl nuw nsw i32 %1, 1
%14 = add nsw i32 %0, -1
%15 = sext i32 %11 to i64
%16 = sext i32 %0 to i64
%17 = zext i32 %1 to i64
%18 = sext i32 %12 to i64
%19 = sext i32 %13 to i64
%20 = sext i32 %14 to i64
%21 = zext i32 %1 to i64
br label %22
22: ; preds = %10, %22
%23 = phi i64 [ 0, %10 ], [ %76, %22 ]
%24 = add nsw i64 %23, %15
%25 = mul nsw i64 %24, %16
%26 = getelementptr inbounds float, float* %2, i64 %25
%27 = load float, float* %26
%28 = add nuw nsw i64 %23, %17
%29 = mul nsw i64 %28, %16
%30 = getelementptr inbounds float, float* %2, i64 %29
%31 = load float, float* %30
%32 = fadd float %27, %31
%33 = fsub float %27, %31
%34 = add nsw i64 %23, %18
%35 = mul nsw i64 %34, %16
%36 = getelementptr inbounds float, float* %2, i64 %35
%37 = load float, float* %36
%38 = add nsw i64 %23, %19
%39 = mul nsw i64 %38, %16
%40 = getelementptr inbounds float, float* %2, i64 %39
%41 = load float, float* %40
%42 = fadd float %37, %41
%43 = fsub float %37, %41
%44 = mul nsw i64 %23, %16
%45 = getelementptr inbounds float, float* %2, i64 %44
%46 = load float, float* %45
%47 = fadd float %32, %46
%48 = fadd float %42, %47
%49 = mul nuw nsw i64 %23, 5
%50 = mul nsw i64 %49, %16
%51 = getelementptr inbounds float, float* %3, i64 %50
store float %48, float* %51
%52 = load float, float* %45
%53 = tail call float @llvm.fmuladd.f32(float %32, float 0x3FD3C6EF40000000, float %52)
%54 = tail call float @llvm.fmuladd.f32(float %42, float 0xBFE9E377A0000000, float %53)
%55 = add nuw nsw i64 %49, 1
%56 = mul nsw i64 %55, %16
%57 = add nsw i64 %56, %20
%58 = getelementptr inbounds float, float* %3, i64 %57
store float %54, float* %58
%59 = fmul float %43, 0x3FE2CF2300000000
%60 = tail call float @llvm.fmuladd.f32(float %33, float 0x3FEE6F0E20000000, float %59)
%61 = add nuw nsw i64 %49, 2
%62 = mul nsw i64 %61, %16
%63 = getelementptr inbounds float, float* %3, i64 %62
store float %60, float* %63
%64 = load float, float* %45
%65 = tail call float @llvm.fmuladd.f32(float %32, float 0xBFE9E377A0000000, float %64)
%66 = tail call float @llvm.fmuladd.f32(float %42, float 0x3FD3C6EF40000000, float %65)
%67 = add nuw nsw i64 %49, 3
%68 = mul nsw i64 %67, %16
%69 = add nsw i64 %68, %20
%70 = getelementptr inbounds float, float* %3, i64 %69
store float %66, float* %70
%71 = fmul float %43, 0xBFEE6F0E20000000
%72 = tail call float @llvm.fmuladd.f32(float %33, float 0x3FE2CF2300000000, float %71)
%73 = add nuw nsw i64 %49, 4
%74 = mul nsw i64 %73, %16
%75 = getelementptr inbounds float, float* %3, i64 %74
store float %72, float* %75
%76 = add nuw nsw i64 %23, 1
%77 = icmp eq i64 %76, %21
br i1 %77, label %78, label %22
78: ; preds = %22
%79 = icmp ne i32 %0, 1
%80 = and i1 %79, %9
br i1 %80, label %81, label %249
81: ; preds = %78
%82 = icmp sgt i32 %0, 2
%83 = shl nuw nsw i32 %1, 1
%84 = mul nsw i32 %1, 3
%85 = shl nsw i32 %1, 2
%86 = sext i32 %0 to i64
%87 = zext i32 %1 to i64
%88 = sext i32 %83 to i64
%89 = sext i32 %84 to i64
%90 = sext i32 %85 to i64
%91 = zext i32 %1 to i64
br label %92
92: ; preds = %81, %246
%93 = phi i64 [ 0, %81 ], [ %247, %246 ]
br i1 %82, label %94, label %246
94: ; preds = %92
%95 = add nuw nsw i64 %93, %87
%96 = mul nsw i64 %95, %86
%97 = add nsw i64 %93, %88
%98 = mul nsw i64 %97, %86
%99 = add nsw i64 %93, %89
%100 = mul nsw i64 %99, %86
%101 = add nsw i64 %93, %90
%102 = mul nsw i64 %101, %86
%103 = mul nsw i64 %93, %86
%104 = mul nuw nsw i64 %93, 5
%105 = mul nsw i64 %104, %86
%106 = add nuw nsw i64 %104, 2
%107 = mul nsw i64 %106, %86
%108 = add nuw nsw i64 %104, 1
%109 = mul nsw i64 %108, %86
%110 = add nuw nsw i64 %104, 4
%111 = mul nsw i64 %110, %86
%112 = add nuw nsw i64 %104, 3
%113 = mul nsw i64 %112, %86
br label %114
114: ; preds = %94, %114
%115 = phi i64 [ 2, %94 ], [ %244, %114 ]
%116 = sub nsw i64 %86, %115
%117 = add nsw i64 %115, -2
%118 = getelementptr inbounds float, float* %4, i64 %117
%119 = load float, float* %118
%120 = add nsw i64 %115, -1
%121 = add nsw i64 %120, %96
%122 = getelementptr inbounds float, float* %2, i64 %121
%123 = load float, float* %122
%124 = getelementptr inbounds float, float* %4, i64 %120
%125 = load float, float* %124
%126 = add nsw i64 %115, %96
%127 = getelementptr inbounds float, float* %2, i64 %126
%128 = load float, float* %127
%129 = fmul float %125, %128
%130 = tail call float @llvm.fmuladd.f32(float %119, float %123, float %129)
%131 = fneg float %125
%132 = fmul float %123, %131
%133 = tail call float @llvm.fmuladd.f32(float %119, float %128, float %132)
%134 = getelementptr inbounds float, float* %5, i64 %117
%135 = load float, float* %134
%136 = add nsw i64 %120, %98
%137 = getelementptr inbounds float, float* %2, i64 %136
%138 = load float, float* %137
%139 = getelementptr inbounds float, float* %5, i64 %120
%140 = load float, float* %139
%141 = add nsw i64 %115, %98
%142 = getelementptr inbounds float, float* %2, i64 %141
%143 = load float, float* %142
%144 = fmul float %140, %143
%145 = tail call float @llvm.fmuladd.f32(float %135, float %138, float %144)
%146 = fneg float %140
%147 = fmul float %138, %146
%148 = tail call float @llvm.fmuladd.f32(float %135, float %143, float %147)
%149 = getelementptr inbounds float, float* %6, i64 %117
%150 = load float, float* %149
%151 = add nsw i64 %120, %100
%152 = getelementptr inbounds float, float* %2, i64 %151
%153 = load float, float* %152
%154 = getelementptr inbounds float, float* %6, i64 %120
%155 = load float, float* %154
%156 = add nsw i64 %115, %100
%157 = getelementptr inbounds float, float* %2, i64 %156
%158 = load float, float* %157
%159 = fmul float %155, %158
%160 = tail call float @llvm.fmuladd.f32(float %150, float %153, float %159)
%161 = fneg float %155
%162 = fmul float %153, %161
%163 = tail call float @llvm.fmuladd.f32(float %150, float %158, float %162)
%164 = getelementptr inbounds float, float* %7, i64 %117
%165 = load float, float* %164
%166 = add nsw i64 %120, %102
%167 = getelementptr inbounds float, float* %2, i64 %166
%168 = load float, float* %167
%169 = getelementptr inbounds float, float* %7, i64 %120
%170 = load float, float* %169
%171 = add nsw i64 %115, %102
%172 = getelementptr inbounds float, float* %2, i64 %171
%173 = load float, float* %172
%174 = fmul float %170, %173
%175 = tail call float @llvm.fmuladd.f32(float %165, float %168, float %174)
%176 = fneg float %170
%177 = fmul float %168, %176
%178 = tail call float @llvm.fmuladd.f32(float %165, float %173, float %177)
%179 = fadd float %130, %175
%180 = fsub float %175, %130
%181 = fsub float %133, %178
%182 = fadd float %133, %178
%183 = fadd float %145, %160
%184 = fsub float %160, %145
%185 = fsub float %148, %163
%186 = fadd float %148, %163
%187 = add nsw i64 %120, %103
%188 = getelementptr inbounds float, float* %2, i64 %187
%189 = load float, float* %188
%190 = fadd float %189, %179
%191 = fadd float %183, %190
%192 = add nsw i64 %120, %105
%193 = getelementptr inbounds float, float* %3, i64 %192
store float %191, float* %193
%194 = add nsw i64 %115, %103
%195 = getelementptr inbounds float, float* %2, i64 %194
%196 = load float, float* %195
%197 = fadd float %182, %196
%198 = fadd float %186, %197
%199 = add nsw i64 %115, %105
%200 = getelementptr inbounds float, float* %3, i64 %199
store float %198, float* %200
%201 = load float, float* %188
%202 = tail call float @llvm.fmuladd.f32(float %179, float 0x3FD3C6EF40000000, float %201)
%203 = tail call float @llvm.fmuladd.f32(float %183, float 0xBFE9E377A0000000, float %202)
%204 = load float, float* %195
%205 = tail call float @llvm.fmuladd.f32(float %182, float 0x3FD3C6EF40000000, float %204)
%206 = tail call float @llvm.fmuladd.f32(float %186, float 0xBFE9E377A0000000, float %205)
%207 = tail call float @llvm.fmuladd.f32(float %179, float 0xBFE9E377A0000000, float %201)
%208 = tail call float @llvm.fmuladd.f32(float %183, float 0x3FD3C6EF40000000, float %207)
%209 = tail call float @llvm.fmuladd.f32(float %182, float 0xBFE9E377A0000000, float %204)
%210 = tail call float @llvm.fmuladd.f32(float %186, float 0x3FD3C6EF40000000, float %209)
%211 = fmul float %185, 0x3FE2CF2300000000
%212 = tail call float @llvm.fmuladd.f32(float %181, float 0x3FEE6F0E20000000, float %211)
%213 = fmul float %184, 0x3FE2CF2300000000
%214 = tail call float @llvm.fmuladd.f32(float %180, float 0x3FEE6F0E20000000, float %213)
%215 = fmul float %185, 0xBFEE6F0E20000000
%216 = tail call float @llvm.fmuladd.f32(float %181, float 0x3FE2CF2300000000, float %215)
%217 = fmul float %184, 0xBFEE6F0E20000000
%218 = tail call float @llvm.fmuladd.f32(float %180, float 0x3FE2CF2300000000, float %217)
%219 = fadd float %212, %203
%220 = add nsw i64 %120, %107
%221 = getelementptr inbounds float, float* %3, i64 %220
store float %219, float* %221
%222 = fsub float %203, %212
%223 = add nsw i64 %116, -1
%224 = add nsw i64 %223, %109
%225 = getelementptr inbounds float, float* %3, i64 %224
store float %222, float* %225
%226 = fadd float %214, %206
%227 = add nsw i64 %115, %107
%228 = getelementptr inbounds float, float* %3, i64 %227
store float %226, float* %228
%229 = fsub float %214, %206
%230 = add nsw i64 %116, %109
%231 = getelementptr inbounds float, float* %3, i64 %230
store float %229, float* %231
%232 = fadd float %216, %208
%233 = add nsw i64 %120, %111
%234 = getelementptr inbounds float, float* %3, i64 %233
store float %232, float* %234
%235 = fsub float %208, %216
%236 = add nsw i64 %223, %113
%237 = getelementptr inbounds float, float* %3, i64 %236
store float %235, float* %237
%238 = fadd float %218, %210
%239 = add nsw i64 %115, %111
%240 = getelementptr inbounds float, float* %3, i64 %239
store float %238, float* %240
%241 = fsub float %218, %210
%242 = add nsw i64 %116, %113
%243 = getelementptr inbounds float, float* %3, i64 %242
store float %241, float* %243
%244 = add nuw nsw i64 %115, 2
%245 = icmp slt i64 %244, %86
br i1 %245, label %114, label %246
246: ; preds = %114, %92
%247 = add nuw nsw i64 %93, 1
%248 = icmp eq i64 %247, %91
br i1 %248, label %249, label %92
249: ; preds = %246, %8, %78
ret void
}