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


x86 assembly (clang, -O0):
<radb4>:
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    12ba <radb4+0x1ba>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x6c(%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  -0x64(%rbp),%xmm0
subss  -0x68(%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  -0x60(%rbp),%xmm0
addss  -0x6c(%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)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1125 <radb4+0x25>
cmpl   $0x2,-0x4(%rbp)
jge    12c9 <radb4+0x1c9>
jmp    19f0 <radb4+0x8f0>
cmpl   $0x2,-0x4(%rbp)
je     181c <radb4+0x71c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17fe <radb4+0x6fe>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17eb <radb4+0x6eb>
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $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
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $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
mov    -0x30(%rbp),%edx
shl    $0x2,%edx
add    $0x3,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
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)
movss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%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)
movss  -0x54(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x44(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x38(%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  -0x38(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
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  -0x48(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x3c(%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  -0x3c(%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
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  -0x4c(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%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  -0x40(%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
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    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ed <radb4+0x1ed>
jmp    17f0 <radb4+0x6f0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12da <radb4+0x1da>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    1817 <radb4+0x717>
jmp    19f0 <radb4+0x8f0>
jmp    181c <radb4+0x71c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19f0 <radb4+0x8f0>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%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  (%rax,%rcx,4),%xmm0
mov    -0x10(%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
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm1
subss  -0x50(%rbp),%xmm1
movss  0x6a8(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x18(%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  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
mov    -0x18(%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
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm1
addss  -0x50(%rbp),%xmm1
movss  0x643(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x18(%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
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1823 <radb4+0x723>
pop    %rbp
ret

x86 assembly (clang, -O2):
<radb4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r13
mov    %rdx,%r15
test   %esi,%esi
jle    11f1 <radb4+0xf1>
lea    (%rsi,%rsi,1),%eax
lea    (%rsi,%rsi,2),%ecx
movslq %edi,%rdx
movslq %eax,%rbx
movslq %ecx,%rcx
mov    %esi,%eax
imul   %rdx,%rcx
lea    0x0(,%rcx,4),%r10
add    %r13,%r10
lea    0x0(,%rdx,4),%r11
imul   %rdx,%rbx
lea    0x0(,%rbx,4),%r12
add    %r13,%r12
lea    (%r15,%rdx,8),%r14
mov    %rdi,-0x50(%rsp)
lea    (%rdx,%rdx,1),%rdi
add    $0xffffffffffffffff,%rdi
lea    (%rdx,%rdx,2),%rbx
lea    (%rdx,%rbx,1),%rcx
add    $0xffffffffffffffff,%rcx
imul   %rax,%rdx
lea    0x0(,%rdx,4),%rbp
add    %r13,%rbp
lea    (%r15,%rdi,4),%rbx
mov    -0x50(%rsp),%rdi
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rdx,4),%xmm0
movss  (%rcx,%rdx,4),%xmm1
movaps %xmm0,%xmm2
subss  %xmm1,%xmm2
addss  %xmm1,%xmm0
movss  (%rbx,%rdx,4),%xmm1
addss  %xmm1,%xmm1
movss  (%r14,%rdx,4),%xmm3
addss  %xmm3,%xmm3
movaps %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,0x0(%r13,%rdx,1)
movaps %xmm2,%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,0x0(%rbp,%rdx,1)
subss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rdx,1)
addss  %xmm2,%xmm3
movss  %xmm3,(%r10,%rdx,1)
add    %r11,%rdx
add    $0xffffffffffffffff,%rax
jne    1190 <radb4+0x90>
cmp    $0x2,%edi
jl     1596 <radb4+0x496>
je     14a1 <radb4+0x3a1>
test   %esi,%esi
jle    1596 <radb4+0x496>
mov    %r15,-0x38(%rsp)
mov    0x38(%rsp),%r15
lea    (%rsi,%rsi,1),%eax
lea    (%rsi,%rsi,2),%ecx
mov    %edi,%r10d
cltq
movslq %ecx,%rcx
mov    %rsi,-0x30(%rsp)
mov    %esi,%edx
imul   %r10,%rcx
lea    0x0(,%rcx,4),%r12
add    %r13,%r12
lea    0x0(,%r10,4),%rcx
mov    %rcx,-0x18(%rsp)
imul   %r10,%rax
lea    0x0(,%rax,4),%rax
add    %r13,%rax
mov    %rdx,-0x10(%rsp)
mov    %rdx,%rcx
imul   %r10,%rcx
lea    0x0(,%rcx,4),%rbx
add    %r13,%rbx
lea    (%rdi,%rdi,1),%r11d
lea    0x0(,%rdi,4),%ecx
mov    %ecx,-0x48(%rsp)
lea    (%rdi,%rdi,2),%esi
lea    -0x2(%r10),%rcx
mov    %rcx,-0x20(%rsp)
xor    %ebp,%ebp
mov    %rdi,-0x50(%rsp)
mov    %r13,-0x28(%rsp)
mov    %r13,%rcx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,-0x3c(%rsp)
mov    %r11d,%edx
movslq %r11d,%rdx
mov    -0x38(%rsp),%r11
lea    (%r11,%rdx,4),%r13
mov    %rbp,-0x8(%rsp)
movslq %ebp,%rdx
lea    (%r11,%rdx,4),%rbp
mov    %esi,-0x40(%rsp)
movslq %esi,%rdx
lea    (%r11,%rdx,4),%rdx
mov    %edi,-0x44(%rsp)
movslq %edi,%rsi
lea    (%r11,%rsi,4),%r11
mov    $0x2,%esi
mov    -0x20(%rsp),%rdi
movss  -0x4(%rbp,%rsi,4),%xmm3
movss  0x0(%rbp,%rsi,4),%xmm2
movss  -0x4(%rdx,%rdi,4),%xmm8
movss  (%rdx,%rdi,4),%xmm1
movaps %xmm2,%xmm0
addss  %xmm1,%xmm0
subss  %xmm1,%xmm2
movss  -0x4(%r13,%rsi,4),%xmm5
movss  0x0(%r13,%rsi,4),%xmm6
movss  -0x4(%r11,%rdi,4),%xmm9
movss  (%r11,%rdi,4),%xmm1
movaps %xmm6,%xmm4
subss  %xmm1,%xmm4
addss  %xmm1,%xmm6
movaps %xmm3,%xmm10
subss  %xmm8,%xmm10
addss  %xmm8,%xmm3
movaps %xmm5,%xmm7
subss  %xmm9,%xmm7
addss  %xmm9,%xmm5
movaps %xmm3,%xmm1
addss  %xmm5,%xmm1
movss  %xmm1,-0x4(%rcx,%rsi,4)
subss  %xmm5,%xmm3
movaps %xmm2,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
subss  %xmm4,%xmm2
movaps %xmm10,%xmm1
subss  %xmm6,%xmm1
addss  %xmm6,%xmm10
movaps %xmm0,%xmm4
addss  %xmm7,%xmm4
subss  %xmm7,%xmm0
movss  -0x4(%r8,%rsi,4),%xmm5
mulss  %xmm4,%xmm5
movss  -0x8(%r8,%rsi,4),%xmm6
mulss  %xmm1,%xmm6
subss  %xmm5,%xmm6
movss  %xmm6,-0x4(%rbx,%rsi,4)
mulss  -0x4(%r8,%rsi,4),%xmm1
mulss  -0x8(%r8,%rsi,4),%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%rbx,%rsi,4)
movss  -0x4(%r9,%rsi,4),%xmm1
mulss  %xmm2,%xmm1
movss  -0x8(%r9,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm1,%xmm4
movss  %xmm4,-0x4(%rax,%rsi,4)
mulss  -0x4(%r9,%rsi,4),%xmm3
mulss  -0x8(%r9,%rsi,4),%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,(%rax,%rsi,4)
movss  -0x4(%r15,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  -0x8(%r15,%rsi,4),%xmm2
mulss  %xmm10,%xmm2
subss  %xmm1,%xmm2
movss  %xmm2,-0x4(%r12,%rsi,4)
mulss  -0x4(%r15,%rsi,4),%xmm10
mulss  -0x8(%r15,%rsi,4),%xmm0
addss  %xmm10,%xmm0
movss  %xmm0,(%r12,%rsi,4)
add    $0x2,%rsi
add    $0xfffffffffffffffe,%rdi
cmp    %r10,%rsi
jb     12e0 <radb4+0x1e0>
add    $0x1,%r14
mov    -0x18(%rsp),%rdx
add    %rdx,%r12
add    %rdx,%rax
add    %rdx,%rbx
add    %rdx,%rcx
mov    -0x3c(%rsp),%r11d
mov    -0x48(%rsp),%edx
add    %edx,%r11d
mov    -0x8(%rsp),%rbp
add    %edx,%ebp
mov    -0x40(%rsp),%esi
add    %edx,%esi
mov    -0x44(%rsp),%edi
add    %edx,%edi
cmp    -0x10(%rsp),%r14
jne    12a0 <radb4+0x1a0>
mov    -0x50(%rsp),%rdi
mov    %edi,%eax
shr    $0x1f,%eax
add    %edi,%eax
and    $0xfffffffe,%eax
mov    %edi,%ecx
sub    %eax,%ecx
cmp    $0x1,%ecx
mov    -0x38(%rsp),%r15
mov    -0x28(%rsp),%r13
mov    -0x30(%rsp),%rsi
je     1596 <radb4+0x496>
test   %esi,%esi
jle    1596 <radb4+0x496>
lea    (%rsi,%rsi,1),%eax
lea    (%rsi,%rsi,2),%ecx
movslq %edi,%rdx
movslq %eax,%rdi
movslq %ecx,%rcx
mov    %esi,%eax
imul   %rdx,%rcx
add    %rdx,%rcx
add    $0xffffffffffffffff,%rcx
lea    0x0(,%rcx,4),%r8
add    %r13,%r8
lea    0x0(,%rdx,4),%r9
imul   %rdx,%rdi
lea    (%rdi,%rdx,1),%rcx
add    $0xffffffffffffffff,%rcx
lea    0x0(,%rcx,4),%r10
add    %r13,%r10
mov    %rdx,%rcx
imul   %rax,%rcx
add    %rdx,%rcx
add    $0xffffffffffffffff,%rcx
lea    0x0(%r13,%rcx,4),%rdi
lea    -0x4(%r13,%rdx,4),%rbp
lea    -0x1(%rdx,%rdx,2),%rcx
lea    (%r15,%rcx,4),%rbx
lea    (%rdx,%rdx,2),%rcx
lea    (%r15,%rcx,4),%rcx
lea    (%r15,%rdx,4),%rdx
xor    %esi,%esi
movss  0xada(%rip),%xmm0
movss  0xad6(%rip),%xmm1
xchg   %ax,%ax
movss  (%rdx,%rsi,4),%xmm2
movss  (%rcx,%rsi,4),%xmm3
movaps %xmm2,%xmm4
addss  %xmm3,%xmm4
subss  %xmm2,%xmm3
movss  -0x4(%rdx,%rsi,4),%xmm2
movss  (%rbx,%rsi,4),%xmm5
movaps %xmm2,%xmm6
subss  %xmm5,%xmm6
addss  %xmm5,%xmm2
addss  %xmm2,%xmm2
movss  %xmm2,0x0(%rbp,%rsi,1)
movaps %xmm6,%xmm2
subss  %xmm4,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rdi,%rsi,1)
addss  %xmm3,%xmm3
movss  %xmm3,(%r10,%rsi,1)
addss  %xmm4,%xmm6
mulss  %xmm1,%xmm6
movss  %xmm6,(%r8,%rsi,1)
add    %r9,%rsi
add    $0xffffffffffffffff,%rax
jne    1530 <radb4+0x430>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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