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


x86 assembly (clang, -O0):
<radb5>:
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    139e <radb5+0x29e>
mov    -0x10(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  0xebd(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
add    $0x4,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  0xe99(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%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  0xe6d(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%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  0xe3e(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  0xdce(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  0xdba(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x5,-0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  0xd89(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  0xd6d(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0xd4b(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movss  0xd42(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0xd28(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xd0a(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%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 <radb5+0x2d>
cmpl   $0x1,-0x4(%rbp)
jne    13ad <radb5+0x2ad>
jmp    1be2 <radb5+0xae2>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1be2 <radb5+0xae2>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1bcf <radb5+0xacf>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
addss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -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
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x68(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -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
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  0x972(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  0x95e(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%rbp),%xmm1
movss  0x927(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x6c(%rbp),%xmm0
movss  0x916(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  0x8dd(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  0x8c1(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x5,-0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%rbp),%xmm1
movss  0x892(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x6c(%rbp),%xmm0
movss  0x879(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  0x854(%rip),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
movss  0x848(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0x82a(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movss  0x821(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  0x804(%rip),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x7e3(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x74(%rbp),%xmm0
movss  0x7cd(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x7af(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x5c(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x3c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x38(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%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    -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  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x78(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x48(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x7c(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%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    -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  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x80(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%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    -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  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x50(%rbp),%xmm2
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    13c7 <radb5+0x2c7>
jmp    1bd4 <radb5+0xad4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13b4 <radb5+0x2b4>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radb5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,-0x74(%rsp)
test   %esi,%esi
jle    16d5 <radb5+0x5d5>
lea    (%rsi,%rsi,1),%eax
lea    (%rsi,%rsi,2),%ebx
lea    0x0(,%rsi,4),%edi
movslq -0x74(%rsp),%r14
movslq %eax,%r10
movslq %ebx,%rbp
movslq %edi,%rdi
mov    %rsi,-0x68(%rsp)
mov    %esi,%ebx
mov    %r14,%rsi
mov    %rdi,%rax
mov    %rdi,-0x30(%rsp)
imul   %rdi,%rsi
mov    %rsi,-0x50(%rsp)
lea    0x0(,%r14,4),%rsi
imul   %r14,%rbp
mov    %rbp,-0x48(%rsp)
mov    %r14,%r13
mov    %r10,%rax
mov    %r10,-0x28(%rsp)
imul   %r10,%r13
mov    %r14,%rax
imul   %rbx,%rax
mov    %rsi,-0x58(%rsp)
lea    (%rsi,%rsi,4),%rsi
mov    %rsi,-0x60(%rsp)
lea    (%r14,%r14,2),%rsi
lea    -0x4(,%r14,4),%rdi
ff
lea    (%rdi,%rsi,4),%r12
lea    (%r14,%r14,1),%r15
add    $0xffffffffffffffff,%r15
mov    %r14,%rdi
shl    $0x4,%rdi
movss  0xe57(%rip),%xmm8
movss  0xe52(%rip),%xmm10
movss  0xe4e(%rip),%xmm7
movss  0xe49(%rip),%xmm9
mov    %rbx,%rsi
mov    %rbx,-0x40(%rsp)
mov    %rdx,%r10
mov    %rcx,%rsi
mov    -0x48(%rsp),%r11
mov    -0x50(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movss  (%r10,%r14,8),%xmm0
addss  %xmm0,%xmm0
movss  (%r10,%rdi,1),%xmm2
addss  %xmm2,%xmm2
movss  (%r10,%r15,4),%xmm4
addss  %xmm4,%xmm4
movss  (%r10,%r12,1),%xmm1
addss  %xmm1,%xmm1
movss  (%r10),%xmm3
addss  %xmm4,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,(%rsi)
movss  (%r10),%xmm5
movaps %xmm4,%xmm6
mulss  %xmm8,%xmm6
addss  %xmm5,%xmm6
movaps %xmm1,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm6,%xmm3
mulss  %xmm10,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm8,%xmm1
addss  %xmm4,%xmm1
movaps %xmm2,%xmm4
mulss  %xmm7,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm4,%xmm5
mulss  0xdad(%rip),%xmm2
mulss  %xmm7,%xmm0
addss  %xmm2,%xmm0
movaps %xmm3,%xmm2
subss  %xmm5,%xmm2
movss  %xmm2,(%rsi,%rax,4)
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,(%rsi,%r13,4)
addss  %xmm1,%xmm0
movss  %xmm0,(%rsi,%r11,4)
addss  %xmm3,%xmm5
movss  %xmm5,(%rsi,%rbp,4)
add    -0x58(%rsp),%rsi
add    -0x60(%rsp),%r10
add    $0xffffffffffffffff,%rbx
jne    11e0 <radb5+0xe0>
cmpl   $0x1,-0x74(%rsp)
mov    -0x68(%rsp),%rax
je     16d5 <radb5+0x5d5>
test   %eax,%eax
jle    16d5 <radb5+0x5d5>
mov    %r14,%r15
lea    (%rax,%rax,2),%eax
cltq
mov    %rax,-0x38(%rsp)
xor    %eax,%eax
mov    %rax,-0x70(%rsp)
movss  0xd20(%rip),%xmm11
movss  0xd1b(%rip),%xmm12
jmp    130c <radb5+0x20c>
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,-0x70(%rsp)
cmp    -0x40(%rsp),%rsi
je     16d5 <radb5+0x5d5>
cmpl   $0x3,-0x74(%rsp)
mov    0x40(%rsp),%rdi
mov    0x38(%rsp),%rsi
jl     12f0 <radb5+0x1f0>
mov    -0x70(%rsp),%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    0x2(,%rbp,4),%rbx
add    %rbp,%rbx
imul   %r15,%rbx
mov    %rbx,-0x50(%rsp)
lea    0x1(,%rbp,4),%rbx
add    %rbp,%rbx
imul   %r15,%rbx
mov    %rbx,-0x58(%rsp)
lea    0x4(,%rbp,4),%rbx
add    %rbp,%rbx
imul   %r15,%rbx
mov    %rbx,-0x60(%rsp)
lea    0x3(,%rbp,4),%rbx
add    %rbp,%rbx
imul   %r15,%rbx
mov    %rbx,-0x68(%rsp)
imul   %r15,%rax
mov    %rax,-0x48(%rsp)
mov    %rbp,%rax
imul   %r15,%rax
mov    %rax,-0x8(%rsp)
mov    -0x40(%rsp),%rax
add    %rbp,%rax
imul   %r15,%rax
mov    %rax,-0x10(%rsp)
mov    -0x28(%rsp),%rax
add    %rbp,%rax
imul   %r15,%rax
mov    %rax,-0x18(%rsp)
mov    -0x38(%rsp),%rax
add    %rbp,%rax
imul   %r15,%rax
mov    %rax,-0x20(%rsp)
mov    -0x30(%rsp),%rax
lea    (%rax,%rbp,1),%r11
imul   %r15,%r11
mov    $0x2,%eax
nopw   0x0(%rax,%rax,1)
mov    %r15,%rbx
sub    %rax,%rbx
mov    -0x50(%rsp),%r14
lea    (%rax,%r14,1),%rbp
movss  (%rdx,%rbp,4),%xmm5
mov    -0x58(%rsp),%r12
lea    (%rbx,%r12,1),%rbp
movss  (%rdx,%rbp,4),%xmm2
movaps %xmm5,%xmm15
subss  %xmm2,%xmm5
mov    -0x60(%rsp),%r13
lea    (%rax,%r13,1),%rbp
movss  (%rdx,%rbp,4),%xmm6
mov    -0x68(%rsp),%r10
lea    (%rbx,%r10,1),%rbp
movss  (%rdx,%rbp,4),%xmm3
movaps %xmm6,%xmm13
subss  %xmm3,%xmm6
lea    -0x1(%rax,%r14,1),%rbp
movss  (%rdx,%rbp,4),%xmm7
lea    -0x1(%rbx,%r12,1),%rbp
movss  (%rdx,%rbp,4),%xmm4
movaps %xmm7,%xmm1
addss  %xmm4,%xmm7
lea    -0x1(%rax,%r13,1),%rbp
movss  (%rdx,%rbp,4),%xmm0
lea    -0x1(%rbx,%r10,1),%rbx
movss  (%rdx,%rbx,4),%xmm8
movaps %xmm0,%xmm14
addss  %xmm8,%xmm0
mov    -0x48(%rsp),%r14
lea    -0x1(%rax,%r14,1),%r10
movaps %xmm9,%xmm10
movss  (%rdx,%r10,4),%xmm9
addss  %xmm7,%xmm9
addss  %xmm0,%xmm9
mov    -0x8(%rsp),%rbx
lea    -0x1(%rax,%rbx,1),%rbp
movss  %xmm9,(%rcx,%rbp,4)
lea    (%rax,%r14,1),%rbp
movss  (%rdx,%rbp,4),%xmm9
addss  %xmm5,%xmm9
addss  %xmm6,%xmm9
lea    (%rax,%rbx,1),%r14
movss  %xmm9,(%rcx,%r14,4)
movss  (%rdx,%r10,4),%xmm9
addss  %xmm2,%xmm15
addss  %xmm3,%xmm13
subss  %xmm4,%xmm1
subss  %xmm8,%xmm14
movaps %xmm7,%xmm2
mulss  %xmm11,%xmm2
addss  %xmm9,%xmm2
movaps %xmm0,%xmm4
mulss  %xmm12,%xmm4
addss  %xmm2,%xmm4
movss  (%rdx,%rbp,4),%xmm8
movaps %xmm5,%xmm3
mulss  %xmm11,%xmm3
addss  %xmm8,%xmm3
movaps %xmm6,%xmm2
mulss  %xmm12,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm12,%xmm7
addss  %xmm9,%xmm7
movaps %xmm10,%xmm9
movss  0xaed(%rip),%xmm10
mulss  %xmm11,%xmm0
addss  %xmm7,%xmm0
mulss  %xmm12,%xmm5
addss  %xmm8,%xmm5
mulss  %xmm11,%xmm6
addss  %xmm5,%xmm6
movaps %xmm14,%xmm3
mulss  %xmm10,%xmm3
movaps %xmm1,%xmm5
mulss  %xmm9,%xmm5
addss  %xmm3,%xmm5
movaps %xmm13,%xmm3
mulss  %xmm10,%xmm3
movaps %xmm15,%xmm7
mulss  %xmm9,%xmm7
addss  %xmm3,%xmm7
mulss  0xaa5(%rip),%xmm14
mulss  %xmm10,%xmm1
addss  %xmm14,%xmm1
movss  0xa93(%rip),%xmm3
mulss  %xmm3,%xmm13
mulss  %xmm10,%xmm15
addss  %xmm13,%xmm15
movaps %xmm0,%xmm8
subss  %xmm15,%xmm8
addss  %xmm0,%xmm15
movaps %xmm1,%xmm3
addss  %xmm6,%xmm3
subss  %xmm1,%xmm6
movaps %xmm7,%xmm0
addss  %xmm4,%xmm0
subss  %xmm7,%xmm4
movaps %xmm2,%xmm1
subss  %xmm5,%xmm1
addss  %xmm2,%xmm5
movss  -0x4(%r8,%rax,4),%xmm2
mulss  %xmm5,%xmm2
movss  -0x8(%r8,%rax,4),%xmm7
mulss  %xmm4,%xmm7
subss  %xmm2,%xmm7
mov    -0x10(%rsp),%rbp
lea    -0x1(%rax,%rbp,1),%rbx
movss  %xmm7,(%rcx,%rbx,4)
mulss  -0x4(%r8,%rax,4),%xmm4
mulss  -0x8(%r8,%rax,4),%xmm5
addss  %xmm4,%xmm5
lea    (%rax,%rbp,1),%rbx
movss  %xmm5,(%rcx,%rbx,4)
movss  -0x4(%r9,%rax,4),%xmm2
mulss  %xmm3,%xmm2
movss  -0x8(%r9,%rax,4),%xmm4
mulss  %xmm8,%xmm4
subss  %xmm2,%xmm4
mov    -0x18(%rsp),%rbp
lea    -0x1(%rax,%rbp,1),%rbx
movss  %xmm4,(%rcx,%rbx,4)
mulss  -0x4(%r9,%rax,4),%xmm8
mulss  -0x8(%r9,%rax,4),%xmm3
addss  %xmm8,%xmm3
lea    (%rax,%rbp,1),%rbx
movss  %xmm3,(%rcx,%rbx,4)
movss  -0x4(%rsi,%rax,4),%xmm2
mulss  %xmm6,%xmm2
movss  -0x8(%rsi,%rax,4),%xmm3
mulss  %xmm15,%xmm3
subss  %xmm2,%xmm3
mov    -0x20(%rsp),%rbp
lea    -0x1(%rax,%rbp,1),%rbx
movss  %xmm3,(%rcx,%rbx,4)
mulss  -0x4(%rsi,%rax,4),%xmm15
mulss  -0x8(%rsi,%rax,4),%xmm6
addss  %xmm15,%xmm6
lea    (%rax,%rbp,1),%rbx
movss  %xmm6,(%rcx,%rbx,4)
movss  -0x4(%rdi,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  -0x8(%rdi,%rax,4),%xmm3
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
lea    -0x1(%rax,%r11,1),%rbx
movss  %xmm3,(%rcx,%rbx,4)
mulss  -0x4(%rdi,%rax,4),%xmm0
mulss  -0x8(%rdi,%rax,4),%xmm1
addss  %xmm0,%xmm1
lea    (%rax,%r11,1),%rbx
movss  %xmm1,(%rcx,%rbx,4)
add    $0x2,%rax
cmp    %r15,%rax
jl     13e0 <radb5+0x2e0>
jmp    12f0 <radb5+0x1f0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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