void radf4(int ido, int l1, const float cc[], float ch[], const float wa1[],
           const float wa2[], const float wa3[]) {
  static const float hsqt2 = 0.7071067811865475;
  int i, k, ic;
  float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
  for (k = 0; k < l1; k++) {
    tr1 = cc[(k + l1) * ido] + cc[(k + 3 * l1) * ido];
    tr2 = cc[k * ido] + cc[(k + 2 * l1) * ido];
    ch[4 * k * ido] = tr1 + tr2;
    ch[ido - 1 + (4 * k + 3) * ido] = tr2 - tr1;
    ch[ido - 1 + (4 * k + 1) * ido] = cc[k * ido] - cc[(k + 2 * l1) * ido];
    ch[(4 * k + 2) * ido] = cc[(k + 3 * l1) * ido] - cc[(k + l1) * ido];
  }
  if (ido < 2)
    return;
  if (ido != 2) {
    for (k = 0; k < l1; k++) {
      for (i = 2; i < ido; i += 2) {
        ic = ido - i;
        cr2 = wa1[i - 2] * cc[i - 1 + (k + l1) * ido] +
              wa1[i - 1] * cc[i + (k + l1) * ido];
        ci2 = wa1[i - 2] * cc[i + (k + l1) * ido] -
              wa1[i - 1] * cc[i - 1 + (k + l1) * ido];
        cr3 = wa2[i - 2] * cc[i - 1 + (k + 2 * l1) * ido] +
              wa2[i - 1] * cc[i + (k + 2 * l1) * ido];
        ci3 = wa2[i - 2] * cc[i + (k + 2 * l1) * ido] -
              wa2[i - 1] * cc[i - 1 + (k + 2 * l1) * ido];
        cr4 = wa3[i - 2] * cc[i - 1 + (k + 3 * l1) * ido] +
              wa3[i - 1] * cc[i + (k + 3 * l1) * ido];
        ci4 = wa3[i - 2] * cc[i + (k + 3 * l1) * ido] -
              wa3[i - 1] * cc[i - 1 + (k + 3 * l1) * ido];
        tr1 = cr2 + cr4;
        tr4 = cr4 - cr2;
        ti1 = ci2 + ci4;
        ti4 = ci2 - ci4;
        ti2 = cc[i + k * ido] + ci3;
        ti3 = cc[i + k * ido] - ci3;
        tr2 = cc[i - 1 + k * ido] + cr3;
        tr3 = cc[i - 1 + k * ido] - cr3;
        ch[i - 1 + 4 * k * ido] = tr1 + tr2;
        ch[ic - 1 + (4 * k + 3) * ido] = tr2 - tr1;
        ch[i + 4 * k * ido] = ti1 + ti2;
        ch[ic + (4 * k + 3) * ido] = ti1 - ti2;
        ch[i - 1 + (4 * k + 2) * ido] = ti4 + tr3;
        ch[ic - 1 + (4 * k + 1) * ido] = tr3 - ti4;
        ch[i + (4 * k + 2) * ido] = tr4 + ti3;
        ch[ic + (4 * k + 1) * ido] = tr4 - ti3;
      }
    }
    if (ido % 2 == 1)
      return;
  }
  for (k = 0; k < l1; k++) {
    ti1 = -hsqt2 *
          (cc[ido - 1 + (k + l1) * ido] + cc[ido - 1 + (k + 3 * l1) * ido]);
    tr1 = hsqt2 *
          (cc[ido - 1 + (k + l1) * ido] - cc[ido - 1 + (k + 3 * l1) * ido]);
    ch[ido - 1 + 4 * k * ido] = tr1 + cc[ido - 1 + k * ido];
    ch[ido - 1 + (4 * k + 2) * ido] = cc[ido - 1 + k * ido] - tr1;
    ch[(4 * k + 1) * ido] = ti1 - cc[ido - 1 + (k + 2 * l1) * ido];
    ch[(4 * k + 3) * ido] = ti1 + cc[ido - 1 + (k + 2 * l1) * ido];
  }
}


x86 assembly (clang, -O0):
<radf4>:
push   %rbp
mov    %rsp,%rbp
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    1288 <radf4+0x188>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
add    %edx,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%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,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%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
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
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
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
add    -0x8(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%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    1125 <radf4+0x25>
cmpl   $0x2,-0x4(%rbp)
jge    1297 <radf4+0x197>
jmp    19a4 <radf4+0x8a4>
cmpl   $0x2,-0x4(%rbp)
je     17e2 <radf4+0x6e2>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17c4 <radf4+0x6c4>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17b1 <radf4+0x6b1>
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,-0x44(%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,-0x38(%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,-0x48(%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,-0x3c(%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,-0x4c(%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,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
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  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
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
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x58(%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  -0x48(%rbp),%xmm0
movss  %xmm0,-0x64(%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
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x1,%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    12bb <radf4+0x1bb>
jmp    17b6 <radf4+0x6b6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12a8 <radf4+0x1a8>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    17dd <radf4+0x6dd>
jmp    19a4 <radf4+0x8a4>
jmp    17e2 <radf4+0x6e2>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19a4 <radf4+0x8a4>
mov    -0x10(%rbp),%rax
mov    -0x4(%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),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%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
addss  (%rax,%rcx,4),%xmm1
movss  0x7c8(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%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),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x4(%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
subss  (%rax,%rcx,4),%xmm1
movss  0x774(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x2,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%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
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4(%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
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%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    17e9 <radf4+0x6e9>
pop    %rbp
ret

x86 assembly (clang, -O2):
<radf4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r12
test   %esi,%esi
jle    11cc <radf4+0xcc>
lea    (%rsi,%rsi,2),%eax
lea    (%rsi,%rsi,1),%ebx
movslq %edi,%rdx
movslq %eax,%rbp
movslq %ebx,%rbx
mov    %esi,%eax
imul   %rdx,%rbx
lea    (%r12,%rbx,4),%r15
lea    0x0(,%rdx,4),%r10
imul   %rdx,%rbp
lea    (%r12,%rbp,4),%r13
lea    (%rcx,%rdx,8),%r11
lea    (%rdx,%rdx,1),%r14
add    $0xffffffffffffffff,%r14
lea    (%rdx,%rdx,2),%rbx
add    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
imul   %rax,%rdx
lea    (%r12,%rdx,4),%rbp
lea    (%rcx,%r14,4),%r14
lea    (%rcx,%rbx,4),%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rbx,1),%xmm0
addss  0x0(%r13,%rbx,1),%xmm0
movss  (%r12,%rbx,1),%xmm1
addss  (%r15,%rbx,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rcx,%rbx,4)
subss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rbx,4)
movss  (%r12,%rbx,1),%xmm0
subss  (%r15,%rbx,1),%xmm0
movss  %xmm0,(%r14,%rbx,4)
movss  0x0(%r13,%rbx,1),%xmm0
subss  0x0(%rbp,%rbx,1),%xmm0
movss  %xmm0,(%r11,%rbx,4)
add    %r10,%rbx
add    $0xffffffffffffffff,%rax
jne    1170 <radf4+0x70>
cmp    $0x2,%edi
jl     155d <radf4+0x45d>
je     1472 <radf4+0x372>
test   %esi,%esi
jle    155d <radf4+0x45d>
mov    %rcx,-0x48(%rsp)
mov    0x38(%rsp),%r10
lea    (%rsi,%rsi,1),%eax
lea    (%rsi,%rsi,2),%ecx
mov    %edi,%r13d
cltq
movslq %ecx,%rcx
mov    %rsi,-0x38(%rsp)
mov    %esi,%edx
lea    (%rdi,%rdi,1),%r11d
lea    0x0(,%rdi,4),%ebp
mov    %ebp,-0x58(%rsp)
lea    0x0(,%r13,4),%rbp
mov    %rbp,-0x20(%rsp)
imul   %r13,%rcx
lea    (%r12,%rcx,4),%rbp
imul   %r13,%rax
lea    (%r12,%rax,4),%rbx
mov    %rdx,-0x18(%rsp)
mov    %rdx,%rax
imul   %r13,%rax
lea    (%r12,%rax,4),%rax
mov    %r12,%rdx
lea    (%rdi,%rdi,2),%r12d
lea    -0x2(%r13),%rcx
mov    %rcx,-0x28(%rsp)
mov    %rdi,-0x40(%rsp)
mov    %edi,%r15d
mov    %rdx,-0x30(%rsp)
xor    %edi,%edi
xor    %esi,%esi
nop
mov    %rsi,-0x10(%rsp)
mov    %r11d,-0x4c(%rsp)
movslq %r11d,%rcx
mov    -0x48(%rsp),%r11
lea    (%r11,%rcx,4),%r14
mov    %rdi,-0x8(%rsp)
movslq %edi,%rcx
lea    (%r11,%rcx,4),%rcx
mov    %r12d,-0x50(%rsp)
movslq %r12d,%rsi
lea    (%r11,%rsi,4),%r12
mov    %r15d,-0x54(%rsp)
movslq %r15d,%rsi
lea    (%r11,%rsi,4),%r11
mov    $0x2,%esi
mov    -0x28(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x8(%r8,%rsi,4),%xmm9
movss  -0x4(%r8,%rsi,4),%xmm1
movss  -0x4(%rax,%rsi,4),%xmm3
movss  (%rax,%rsi,4),%xmm4
movaps %xmm9,%xmm2
mulss  %xmm3,%xmm2
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
addss  %xmm1,%xmm2
mulss  %xmm4,%xmm9
subss  %xmm3,%xmm9
movss  -0x8(%r9,%rsi,4),%xmm4
movss  -0x4(%r9,%rsi,4),%xmm1
movss  -0x4(%rbx,%rsi,4),%xmm5
movss  (%rbx,%rsi,4),%xmm6
movaps %xmm4,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm5
mulss  %xmm6,%xmm1
addss  %xmm1,%xmm0
mulss  %xmm6,%xmm4
subss  %xmm5,%xmm4
movss  -0x8(%r10,%rsi,4),%xmm5
movss  -0x4(%r10,%rsi,4),%xmm6
movss  -0x4(%rbp,%rsi,4),%xmm7
movss  0x0(%rbp,%rsi,4),%xmm8
movaps %xmm5,%xmm1
mulss  %xmm7,%xmm1
mulss  %xmm6,%xmm7
mulss  %xmm8,%xmm6
addss  %xmm6,%xmm1
mulss  %xmm8,%xmm5
subss  %xmm7,%xmm5
movaps %xmm2,%xmm6
addss  %xmm1,%xmm6
subss  %xmm2,%xmm1
movaps %xmm9,%xmm2
addss  %xmm5,%xmm2
subss  %xmm5,%xmm9
movss  -0x4(%rdx,%rsi,4),%xmm5
movss  (%rdx,%rsi,4),%xmm7
movaps %xmm4,%xmm3
addss  %xmm7,%xmm3
subss  %xmm4,%xmm7
movaps %xmm0,%xmm4
addss  %xmm5,%xmm4
subss  %xmm0,%xmm5
movaps %xmm6,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x4(%rcx,%rsi,4)
subss  %xmm6,%xmm4
movss  %xmm4,-0x4(%r12,%rdi,4)
movaps %xmm2,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
subss  %xmm3,%xmm2
movss  %xmm2,(%r12,%rdi,4)
movaps %xmm9,%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,-0x4(%r14,%rsi,4)
subss  %xmm9,%xmm5
movss  %xmm5,-0x4(%r11,%rdi,4)
movaps %xmm7,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r14,%rsi,4)
subss  %xmm7,%xmm1
movss  %xmm1,(%r11,%rdi,4)
add    $0x2,%rsi
add    $0xfffffffffffffffe,%rdi
cmp    %r13,%rsi
jb     12b0 <radf4+0x1b0>
mov    -0x10(%rsp),%rsi
add    $0x1,%rsi
mov    -0x4c(%rsp),%r11d
mov    -0x58(%rsp),%r14d
add    %r14d,%r11d
mov    -0x8(%rsp),%rdi
add    %r14d,%edi
mov    -0x20(%rsp),%rcx
add    %rcx,%rdx
add    %rcx,%rbp
add    %rcx,%rbx
add    %rcx,%rax
mov    -0x50(%rsp),%r12d
add    %r14d,%r12d
mov    -0x54(%rsp),%r15d
add    %r14d,%r15d
cmp    -0x18(%rsp),%rsi
jne    1260 <radf4+0x160>
mov    -0x40(%rsp),%rdi
mov    %edi,%eax
shr    $0x1f,%eax
add    %edi,%eax
and    $0xfffffffe,%eax
mov    %edi,%ecx
sub    %eax,%ecx
cmp    $0x1,%ecx
mov    -0x48(%rsp),%rcx
mov    -0x30(%rsp),%r12
mov    -0x38(%rsp),%rsi
je     155d <radf4+0x45d>
test   %esi,%esi
jle    155d <radf4+0x45d>
lea    (%rsi,%rsi,2),%eax
lea    (%rsi,%rsi,1),%ebp
movslq %edi,%rdi
movslq %eax,%rdx
movslq %ebp,%rbp
mov    %esi,%eax
imul   %rdi,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0xffffffffffffffff,%rsi
lea    (%r12,%rsi,4),%rbx
lea    0x0(,%rdi,4),%r8
lea    (%r12,%rdi,4),%rsi
add    $0xfffffffffffffffc,%rsi
imul   %rdi,%rdx
add    %rdi,%rdx
add    $0xffffffffffffffff,%rdx
lea    (%r12,%rdx,4),%r9
mov    %rdi,%rdx
imul   %rax,%rdx
add    %rdi,%rdx
add    $0xffffffffffffffff,%rdx
lea    (%r12,%rdx,4),%r10
lea    (%rdi,%rdi,2),%rdx
lea    (%rcx,%rdx,4),%r11
lea    (%rcx,%rdi,4),%rdx
lea    (%rdi,%rdi,2),%rdi
add    $0xffffffffffffffff,%rdi
lea    (%rcx,%rdi,4),%rdi
xor    %ebp,%ebp
movss  0xb12(%rip),%xmm0
movss  0xb0e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movss  (%r10,%rbp,1),%xmm2
movss  (%r9,%rbp,1),%xmm3
movaps %xmm2,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm0,%xmm4
subss  %xmm3,%xmm2
mulss  %xmm1,%xmm2
movss  (%rsi,%rbp,1),%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x4(%rdx,%rbp,4)
movss  (%rsi,%rbp,1),%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,(%rdi,%rbp,4)
movaps %xmm4,%xmm2
subss  (%rbx,%rbp,1),%xmm2
movss  %xmm2,(%rdx,%rbp,4)
addss  (%rbx,%rbp,1),%xmm4
movss  %xmm4,(%r11,%rbp,4)
add    %r8,%rbp
add    $0xffffffffffffffff,%rax
jne    1500 <radf4+0x400>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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