void bfR4(float *ioptr, int M, int NDiffU) {
  unsigned int pos;
  unsigned int posi;
  unsigned int pinc;
  unsigned int pnext;
  unsigned int pnexti;
  unsigned int NSameU;
  unsigned int SameUCnt;
  float *pstrt;
  float *p0r, *p1r, *p2r, *p3r;
  float w1r = 1.0 / 1.414213562373095048801688724209698078569;
  float f0r, f0i, f1r, f1i, f2r, f2i, f3r, f3i;
  float f4r, f4i, f5r, f5i, f6r, f6i, f7r, f7i;
  float t1r, t1i;
  const float Two = 2.0;
  pinc = NDiffU * 2;
  pnext = pinc * 4;
  pnexti = pnext + 1;
  pos = 2;
  posi = pos + 1;
  NSameU = ((unsigned long)1 << (M)) / 4 / NDiffU;
  pstrt = ioptr;
  p0r = pstrt;
  p1r = pstrt + pinc;
  p2r = p1r + pinc;
  p3r = p2r + pinc;
  f0r = *p0r;
  f1r = *p1r;
  f2r = *p2r;
  f3r = *p3r;
  f0i = *(p0r + 1);
  f1i = *(p1r + 1);
  f2i = *(p2r + 1);
  f3i = *(p3r + 1);
  f5r = f0r - f1r;
  f5i = f0i - f1i;
  f0r = f0r + f1r;
  f0i = f0i + f1i;
  f6r = f2r + f3r;
  f6i = f2i + f3i;
  f3r = f2r - f3r;
  f3i = f2i - f3i;
  for (SameUCnt = NSameU - 1; SameUCnt > 0; SameUCnt--) {
    f7r = f5r - f3i;
    f7i = f5i + f3r;
    f5r = f5r + f3i;
    f5i = f5i - f3r;
    f4r = f0r + f6r;
    f4i = f0i + f6i;
    f6r = f0r - f6r;
    f6i = f0i - f6i;
    f2r = *(p2r + pos);
    f2i = *(p2r + posi);
    f1r = *(p1r + pos);
    f1i = *(p1r + posi);
    f3i = *(p3r + posi);
    f0r = *(p0r + pos);
    f3r = *(p3r + pos);
    f0i = *(p0r + posi);
    *p3r = f7r;
    *p0r = f4r;
    *(p3r + 1) = f7i;
    *(p0r + 1) = f4i;
    *p1r = f5r;
    *p2r = f6r;
    *(p1r + 1) = f5i;
    *(p2r + 1) = f6i;
    f7r = f2r - f3i;
    f7i = f2i + f3r;
    f2r = f2r + f3i;
    f2i = f2i - f3r;
    f4r = f0r + f1i;
    f4i = f0i - f1r;
    t1r = f0r - f1i;
    t1i = f0i + f1r;
    f5r = t1r - f7r * w1r + f7i * w1r;
    f5i = t1i - f7r * w1r - f7i * w1r;
    f7r = t1r * Two - f5r;
    f7i = t1i * Two - f5i;
    f6r = f4r - f2r * w1r - f2i * w1r;
    f6i = f4i + f2r * w1r - f2i * w1r;
    f4r = f4r * Two - f6r;
    f4i = f4i * Two - f6i;
    f3r = *(p3r + pnext);
    f0r = *(p0r + pnext);
    f3i = *(p3r + pnexti);
    f0i = *(p0r + pnexti);
    f2r = *(p2r + pnext);
    f2i = *(p2r + pnexti);
    f1r = *(p1r + pnext);
    f1i = *(p1r + pnexti);
    *(p2r + pos) = f6r;
    *(p1r + pos) = f5r;
    *(p2r + posi) = f6i;
    *(p1r + posi) = f5i;
    *(p3r + pos) = f7r;
    *(p0r + pos) = f4r;
    *(p3r + posi) = f7i;
    *(p0r + posi) = f4i;
    f6r = f2r + f3r;
    f6i = f2i + f3i;
    f3r = f2r - f3r;
    f3i = f2i - f3i;
    f5r = f0r - f1r;
    f5i = f0i - f1i;
    f0r = f0r + f1r;
    f0i = f0i + f1i;
    p3r += pnext;
    p0r += pnext;
    p1r += pnext;
    p2r += pnext;
  }
  f7r = f5r - f3i;
  f7i = f5i + f3r;
  f5r = f5r + f3i;
  f5i = f5i - f3r;
  f4r = f0r + f6r;
  f4i = f0i + f6i;
  f6r = f0r - f6r;
  f6i = f0i - f6i;
  f2r = *(p2r + pos);
  f2i = *(p2r + posi);
  f1r = *(p1r + pos);
  f1i = *(p1r + posi);
  f3i = *(p3r + posi);
  f0r = *(p0r + pos);
  f3r = *(p3r + pos);
  f0i = *(p0r + posi);
  *p3r = f7r;
  *p0r = f4r;
  *(p3r + 1) = f7i;
  *(p0r + 1) = f4i;
  *p1r = f5r;
  *p2r = f6r;
  *(p1r + 1) = f5i;
  *(p2r + 1) = f6i;
  f7r = f2r - f3i;
  f7i = f2i + f3r;
  f2r = f2r + f3i;
  f2i = f2i - f3r;
  f4r = f0r + f1i;
  f4i = f0i - f1r;
  t1r = f0r - f1i;
  t1i = f0i + f1r;
  f5r = t1r - f7r * w1r + f7i * w1r;
  f5i = t1i - f7r * w1r - f7i * w1r;
  f7r = t1r * Two - f5r;
  f7i = t1i * Two - f5i;
  f6r = f4r - f2r * w1r - f2i * w1r;
  f6i = f4i + f2r * w1r - f2i * w1r;
  f4r = f4r * Two - f6r;
  f4i = f4i * Two - f6i;
  *(p2r + pos) = f6r;
  *(p1r + pos) = f5r;
  *(p2r + posi) = f6i;
  *(p1r + posi) = f5i;
  *(p3r + pos) = f7r;
  *(p0r + pos) = f4r;
  *(p3r + posi) = f7i;
  *(p0r + posi) = f4i;
}


x86 assembly (clang, -O0):
<bfR4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x28,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  0xeea(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0xed9(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
shr    $0x2,%rax
movslq -0x10(%rbp),%rcx
xor    %edx,%edx
div    %rcx
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x74(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x70(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jbe    18d1 <bfR4+0x7d1>
movss  -0x88(%rbp),%xmm0
ff
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x70(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x70(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0x70(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  -0x70(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x70(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x48(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x50(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b6 <bfR4+0x1b6>
movss  -0x88(%rbp),%xmm0
ff
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x70(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x70(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x60(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x60(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x64(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0x70(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  -0x70(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
add    $0x28,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bfR4>:
mov    %edx,%r8d
mov    %esi,%ecx
lea    (%r8,%r8,1),%esi
mov    $0x1,%eax
shl    %cl,%rax
shr    $0x2,%rax
movslq %edx,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
je     112b <bfR4+0x2b>
xor    %edx,%edx
div    %rcx
jmp    1130 <bfR4+0x30>
xor    %edx,%edx
div    %r8d
push   %rbx
mov    %esi,%r9d
lea    (%rdi,%r9,4),%rcx
lea    (%rcx,%r9,4),%rdx
movss  (%rdi),%xmm11
movss  0x4(%rdi),%xmm10
movss  (%rdi,%r9,4),%xmm0
movss  0x4(%rdi,%r9,4),%xmm1
movss  (%rcx,%r9,4),%xmm5
movss  0x4(%rcx,%r9,4),%xmm12
movss  (%rdx,%r9,4),%xmm2
movss  0x4(%rdx,%r9,4),%xmm8
movaps %xmm11,%xmm6
subss  %xmm0,%xmm6
movaps %xmm10,%xmm3
subss  %xmm1,%xmm3
addss  %xmm0,%xmm11
addss  %xmm1,%xmm10
movaps %xmm5,%xmm7
addss  %xmm2,%xmm7
movaps %xmm12,%xmm4
addss  %xmm8,%xmm4
subss  %xmm2,%xmm5
subss  %xmm8,%xmm12
add    $0xffffffff,%eax
je     13d3 <bfR4+0x2d3>
shl    $0x3,%r8d
mov    %r8d,%ebx
lea    0x0(,%rbx,4),%r10
lea    0x0(,%r9,4),%rsi
lea    (%rsi,%rsi,2),%rcx
lea    (%rcx,%rbx,4),%r8
lea    0x0(,%r9,8),%rdx
lea    (%r10,%r9,8),%r11
lea    (%rsi,%rbx,4),%rbx
nopl   0x0(%rax)
movaps %xmm6,%xmm13
subss  %xmm12,%xmm13
movaps %xmm5,%xmm1
addss  %xmm3,%xmm1
addss  %xmm6,%xmm12
subss  %xmm5,%xmm3
movaps %xmm11,%xmm2
addss  %xmm7,%xmm2
movaps %xmm10,%xmm0
addss  %xmm4,%xmm0
subss  %xmm7,%xmm11
subss  %xmm4,%xmm10
movss  0x8(%rdi,%rdx,1),%xmm6
movss  0xc(%rdi,%rdx,1),%xmm5
movss  0x8(%rdi,%rsi,1),%xmm9
movss  0xc(%rdi,%rsi,1),%xmm14
movss  0x8(%rdi,%rcx,1),%xmm15
movss  0xc(%rdi,%rcx,1),%xmm8
movss  0x8(%rdi),%xmm7
movss  0xc(%rdi),%xmm4
movss  %xmm13,(%rdi,%rcx,1)
movss  %xmm2,(%rdi)
movss  %xmm1,0x4(%rdi,%rcx,1)
movss  %xmm0,0x4(%rdi)
movss  %xmm12,(%rdi,%rsi,1)
movss  %xmm11,(%rdi,%rdx,1)
movss  %xmm3,0x4(%rdi,%rsi,1)
movss  %xmm10,0x4(%rdi,%rdx,1)
movaps %xmm6,%xmm3
subss  %xmm8,%xmm3
movaps %xmm5,%xmm2
addss  %xmm15,%xmm2
addss  %xmm8,%xmm6
subss  %xmm15,%xmm5
movaps %xmm14,%xmm0
addss  %xmm7,%xmm0
movaps %xmm4,%xmm1
subss  %xmm9,%xmm1
subss  %xmm14,%xmm7
addss  %xmm4,%xmm9
movaps 0xd51(%rip),%xmm10
xorps  %xmm10,%xmm3
movss  0xd55(%rip),%xmm4
mulss  %xmm4,%xmm3
movaps %xmm3,%xmm8
addss  %xmm7,%xmm8
mulss  %xmm4,%xmm2
addss  %xmm2,%xmm8
addss  %xmm9,%xmm3
subss  %xmm2,%xmm3
mulss  %xmm4,%xmm6
movaps %xmm0,%xmm2
subss  %xmm6,%xmm2
xorps  %xmm10,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm5,%xmm2
addss  %xmm1,%xmm6
addss  %xmm5,%xmm6
addss  %xmm0,%xmm0
subss  %xmm2,%xmm0
movss  (%rdi,%r8,1),%xmm4
movss  0x4(%rdi,%r8,1),%xmm13
movss  (%rdi,%r10,1),%xmm11
movss  0x4(%rdi,%r10,1),%xmm10
movss  (%rdi,%r11,1),%xmm5
movss  0x4(%rdi,%r11,1),%xmm12
movss  (%rdi,%rbx,1),%xmm14
movss  0x4(%rdi,%rbx,1),%xmm15
movss  %xmm2,0x8(%rdi,%rdx,1)
addss  %xmm7,%xmm7
subss  %xmm8,%xmm7
movss  %xmm8,0x8(%rdi,%rsi,1)
addss  %xmm1,%xmm1
subss  %xmm6,%xmm1
movss  %xmm6,0xc(%rdi,%rdx,1)
addss  %xmm9,%xmm9
subss  %xmm3,%xmm9
movss  %xmm3,0xc(%rdi,%rsi,1)
movss  %xmm7,0x8(%rdi,%rcx,1)
movss  %xmm0,0x8(%rdi)
movss  %xmm9,0xc(%rdi,%rcx,1)
movss  %xmm1,0xc(%rdi)
movaps %xmm4,%xmm7
addss  %xmm5,%xmm7
subss  %xmm4,%xmm5
movaps %xmm13,%xmm4
addss  %xmm12,%xmm4
subss  %xmm13,%xmm12
movaps %xmm11,%xmm6
subss  %xmm14,%xmm6
addss  %xmm14,%xmm11
movaps %xmm10,%xmm3
subss  %xmm15,%xmm3
addss  %xmm15,%xmm10
add    %r10,%rdi
add    $0xffffffff,%eax
jne    11e0 <bfR4+0xe0>
lea    (%r9,%r9,2),%rax
lea    (%rdi,%rax,4),%rax
lea    (%rdi,%r9,8),%rdx
lea    (%rdi,%r9,4),%rcx
jmp    13d7 <bfR4+0x2d7>
lea    (%rdx,%r9,4),%rax
movaps %xmm6,%xmm8
subss  %xmm12,%xmm8
movaps %xmm5,%xmm1
addss  %xmm3,%xmm1
addss  %xmm6,%xmm12
subss  %xmm5,%xmm3
movaps %xmm11,%xmm2
addss  %xmm7,%xmm2
movaps %xmm10,%xmm0
addss  %xmm4,%xmm0
subss  %xmm7,%xmm11
subss  %xmm4,%xmm10
movss  0x8(%rdx),%xmm5
movss  0xc(%rdx),%xmm7
movss  0x8(%rcx),%xmm4
movss  0xc(%rcx),%xmm9
movss  0x8(%rax),%xmm13
movss  0xc(%rax),%xmm14
movss  0x8(%rdi),%xmm6
movss  0xc(%rdi),%xmm15
movss  %xmm8,(%rax)
movss  %xmm2,(%rdi)
movss  %xmm1,0x4(%rax)
movss  %xmm0,0x4(%rdi)
movss  %xmm12,(%rcx)
movss  %xmm11,(%rdx)
movss  %xmm3,0x4(%rcx)
movss  %xmm10,0x4(%rdx)
movaps %xmm5,%xmm0
subss  %xmm14,%xmm0
movaps %xmm7,%xmm3
addss  %xmm13,%xmm3
addss  %xmm14,%xmm5
subss  %xmm13,%xmm7
movaps %xmm9,%xmm1
addss  %xmm6,%xmm1
movaps %xmm15,%xmm2
subss  %xmm4,%xmm2
subss  %xmm9,%xmm6
addss  %xmm15,%xmm4
movaps 0xb66(%rip),%xmm9
xorps  %xmm9,%xmm0
movss  0xb69(%rip),%xmm10
mulss  %xmm10,%xmm0
movaps %xmm0,%xmm8
addss  %xmm6,%xmm8
mulss  %xmm10,%xmm3
addss  %xmm3,%xmm8
addss  %xmm4,%xmm0
subss  %xmm3,%xmm0
addss  %xmm6,%xmm6
subss  %xmm8,%xmm6
addss  %xmm4,%xmm4
subss  %xmm0,%xmm4
mulss  %xmm10,%xmm5
movaps %xmm1,%xmm3
subss  %xmm5,%xmm3
xorps  %xmm9,%xmm7
mulss  %xmm10,%xmm7
addss  %xmm7,%xmm3
addss  %xmm2,%xmm5
addss  %xmm7,%xmm5
addss  %xmm1,%xmm1
subss  %xmm3,%xmm1
addss  %xmm2,%xmm2
subss  %xmm5,%xmm2
movss  %xmm3,0x8(%rdx)
movss  %xmm8,0x8(%rcx)
movss  %xmm5,0xc(%rdx)
movss  %xmm0,0xc(%rcx)
movss  %xmm6,0x8(%rax)
movss  %xmm1,0x8(%rdi)
movss  %xmm4,0xc(%rax)
movss  %xmm2,0xc(%rdi)
pop    %rbx
ret

LLVM IR (-O0):
define void @bfR4(float* %0, i32 %1, i32 %2) {
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%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
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
store float* %0, float** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store float 0x3FE6A09E60000000, float* %19
store float 2.000000e+00, float* %38
%39 = load i32, i32* %6
%40 = mul nsw i32 %39, 2
store i32 %40, i32* %9
%41 = load i32, i32* %9
%42 = mul i32 %41, 4
store i32 %42, i32* %10
%43 = load i32, i32* %10
%44 = add i32 %43, 1
store i32 %44, i32* %11
store i32 2, i32* %7
%45 = load i32, i32* %7
%46 = add i32 %45, 1
store i32 %46, i32* %8
%47 = load i32, i32* %5
%48 = zext i32 %47 to i64
%49 = shl i64 1, %48
%50 = udiv i64 %49, 4
%51 = load i32, i32* %6
%52 = sext i32 %51 to i64
%53 = udiv i64 %50, %52
%54 = trunc i64 %53 to i32
store i32 %54, i32* %12
%55 = load float*, float** %4
store float* %55, float** %14
%56 = load float*, float** %14
store float* %56, float** %15
%57 = load float*, float** %14
%58 = load i32, i32* %9
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
store float* %60, float** %16
%61 = load float*, float** %16
%62 = load i32, i32* %9
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds float, float* %61, i64 %63
store float* %64, float** %17
%65 = load float*, float** %17
%66 = load i32, i32* %9
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float* %68, float** %18
%69 = load float*, float** %15
%70 = load float, float* %69
store float %70, float* %20
%71 = load float*, float** %16
%72 = load float, float* %71
store float %72, float* %22
%73 = load float*, float** %17
%74 = load float, float* %73
store float %74, float* %24
%75 = load float*, float** %18
%76 = load float, float* %75
store float %76, float* %26
%77 = load float*, float** %15
%78 = getelementptr inbounds float, float* %77, i64 1
%79 = load float, float* %78
store float %79, float* %21
%80 = load float*, float** %16
%81 = getelementptr inbounds float, float* %80, i64 1
%82 = load float, float* %81
store float %82, float* %23
%83 = load float*, float** %17
%84 = getelementptr inbounds float, float* %83, i64 1
%85 = load float, float* %84
store float %85, float* %25
%86 = load float*, float** %18
%87 = getelementptr inbounds float, float* %86, i64 1
%88 = load float, float* %87
store float %88, float* %27
%89 = load float, float* %20
%90 = load float, float* %22
%91 = fsub float %89, %90
store float %91, float* %30
%92 = load float, float* %21
%93 = load float, float* %23
%94 = fsub float %92, %93
store float %94, float* %31
%95 = load float, float* %20
%96 = load float, float* %22
%97 = fadd float %95, %96
store float %97, float* %20
%98 = load float, float* %21
%99 = load float, float* %23
%100 = fadd float %98, %99
store float %100, float* %21
%101 = load float, float* %24
%102 = load float, float* %26
%103 = fadd float %101, %102
store float %103, float* %32
%104 = load float, float* %25
%105 = load float, float* %27
%106 = fadd float %104, %105
store float %106, float* %33
%107 = load float, float* %24
%108 = load float, float* %26
%109 = fsub float %107, %108
store float %109, float* %26
%110 = load float, float* %25
%111 = load float, float* %27
%112 = fsub float %110, %111
store float %112, float* %27
%113 = load i32, i32* %12
%114 = sub i32 %113, 1
store i32 %114, i32* %13
br label %115
115: ; preds = %397, %3
%116 = load i32, i32* %13
%117 = icmp ugt i32 %116, 0
br i1 %117, label %118, label %400
118: ; preds = %115
%119 = load float, float* %30
%120 = load float, float* %27
%121 = fsub float %119, %120
store float %121, float* %34
%122 = load float, float* %31
%123 = load float, float* %26
%124 = fadd float %122, %123
store float %124, float* %35
%125 = load float, float* %30
%126 = load float, float* %27
%127 = fadd float %125, %126
store float %127, float* %30
%128 = load float, float* %31
%129 = load float, float* %26
%130 = fsub float %128, %129
store float %130, float* %31
%131 = load float, float* %20
%132 = load float, float* %32
%133 = fadd float %131, %132
store float %133, float* %28
%134 = load float, float* %21
%135 = load float, float* %33
%136 = fadd float %134, %135
store float %136, float* %29
%137 = load float, float* %20
%138 = load float, float* %32
%139 = fsub float %137, %138
store float %139, float* %32
%140 = load float, float* %21
%141 = load float, float* %33
%142 = fsub float %140, %141
store float %142, float* %33
%143 = load float*, float** %17
%144 = load i32, i32* %7
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds float, float* %143, i64 %145
%147 = load float, float* %146
store float %147, float* %24
%148 = load float*, float** %17
%149 = load i32, i32* %8
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
store float %152, float* %25
%153 = load float*, float** %16
%154 = load i32, i32* %7
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
%157 = load float, float* %156
store float %157, float* %22
%158 = load float*, float** %16
%159 = load i32, i32* %8
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
%162 = load float, float* %161
store float %162, float* %23
%163 = load float*, float** %18
%164 = load i32, i32* %8
%165 = zext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
%167 = load float, float* %166
store float %167, float* %27
%168 = load float*, float** %15
%169 = load i32, i32* %7
%170 = zext i32 %169 to i64
%171 = getelementptr inbounds float, float* %168, i64 %170
%172 = load float, float* %171
store float %172, float* %20
%173 = load float*, float** %18
%174 = load i32, i32* %7
%175 = zext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
store float %177, float* %26
%178 = load float*, float** %15
%179 = load i32, i32* %8
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds float, float* %178, i64 %180
%182 = load float, float* %181
store float %182, float* %21
%183 = load float, float* %34
%184 = load float*, float** %18
store float %183, float* %184
%185 = load float, float* %28
%186 = load float*, float** %15
store float %185, float* %186
%187 = load float, float* %35
%188 = load float*, float** %18
%189 = getelementptr inbounds float, float* %188, i64 1
store float %187, float* %189
%190 = load float, float* %29
%191 = load float*, float** %15
%192 = getelementptr inbounds float, float* %191, i64 1
store float %190, float* %192
%193 = load float, float* %30
%194 = load float*, float** %16
store float %193, float* %194
%195 = load float, float* %32
%196 = load float*, float** %17
store float %195, float* %196
%197 = load float, float* %31
%198 = load float*, float** %16
%199 = getelementptr inbounds float, float* %198, i64 1
store float %197, float* %199
%200 = load float, float* %33
%201 = load float*, float** %17
%202 = getelementptr inbounds float, float* %201, i64 1
store float %200, float* %202
%203 = load float, float* %24
%204 = load float, float* %27
%205 = fsub float %203, %204
store float %205, float* %34
%206 = load float, float* %25
%207 = load float, float* %26
%208 = fadd float %206, %207
store float %208, float* %35
%209 = load float, float* %24
%210 = load float, float* %27
%211 = fadd float %209, %210
store float %211, float* %24
%212 = load float, float* %25
%213 = load float, float* %26
%214 = fsub float %212, %213
store float %214, float* %25
%215 = load float, float* %20
%216 = load float, float* %23
%217 = fadd float %215, %216
store float %217, float* %28
%218 = load float, float* %21
%219 = load float, float* %22
%220 = fsub float %218, %219
store float %220, float* %29
%221 = load float, float* %20
%222 = load float, float* %23
%223 = fsub float %221, %222
store float %223, float* %36
%224 = load float, float* %21
%225 = load float, float* %22
%226 = fadd float %224, %225
store float %226, float* %37
%227 = load float, float* %36
%228 = load float, float* %34
%229 = load float, float* %19
%230 = fneg float %228
%231 = call float @llvm.fmuladd.f32(float %230, float %229, float %227)
%232 = load float, float* %35
%233 = load float, float* %19
%234 = call float @llvm.fmuladd.f32(float %232, float %233, float %231)
store float %234, float* %30
%235 = load float, float* %37
%236 = load float, float* %34
%237 = load float, float* %19
%238 = fneg float %236
%239 = call float @llvm.fmuladd.f32(float %238, float %237, float %235)
%240 = load float, float* %35
%241 = load float, float* %19
%242 = fneg float %240
%243 = call float @llvm.fmuladd.f32(float %242, float %241, float %239)
store float %243, float* %31
%244 = load float, float* %36
%245 = load float, float* %30
%246 = fneg float %245
%247 = call float @llvm.fmuladd.f32(float %244, float 2.000000e+00, float %246)
store float %247, float* %34
%248 = load float, float* %37
%249 = load float, float* %31
%250 = fneg float %249
%251 = call float @llvm.fmuladd.f32(float %248, float 2.000000e+00, float %250)
store float %251, float* %35
%252 = load float, float* %28
%253 = load float, float* %24
%254 = load float, float* %19
%255 = fneg float %253
%256 = call float @llvm.fmuladd.f32(float %255, float %254, float %252)
%257 = load float, float* %25
%258 = load float, float* %19
%259 = fneg float %257
%260 = call float @llvm.fmuladd.f32(float %259, float %258, float %256)
store float %260, float* %32
%261 = load float, float* %29
%262 = load float, float* %24
%263 = load float, float* %19
%264 = call float @llvm.fmuladd.f32(float %262, float %263, float %261)
%265 = load float, float* %25
%266 = load float, float* %19
%267 = fneg float %265
%268 = call float @llvm.fmuladd.f32(float %267, float %266, float %264)
store float %268, float* %33
%269 = load float, float* %28
%270 = load float, float* %32
%271 = fneg float %270
%272 = call float @llvm.fmuladd.f32(float %269, float 2.000000e+00, float %271)
store float %272, float* %28
%273 = load float, float* %29
%274 = load float, float* %33
%275 = fneg float %274
%276 = call float @llvm.fmuladd.f32(float %273, float 2.000000e+00, float %275)
store float %276, float* %29
%277 = load float*, float** %18
%278 = load i32, i32* %10
%279 = zext i32 %278 to i64
%280 = getelementptr inbounds float, float* %277, i64 %279
%281 = load float, float* %280
store float %281, float* %26
%282 = load float*, float** %15
%283 = load i32, i32* %10
%284 = zext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
%286 = load float, float* %285
store float %286, float* %20
%287 = load float*, float** %18
%288 = load i32, i32* %11
%289 = zext i32 %288 to i64
%290 = getelementptr inbounds float, float* %287, i64 %289
%291 = load float, float* %290
store float %291, float* %27
%292 = load float*, float** %15
%293 = load i32, i32* %11
%294 = zext i32 %293 to i64
%295 = getelementptr inbounds float, float* %292, i64 %294
%296 = load float, float* %295
store float %296, float* %21
%297 = load float*, float** %17
%298 = load i32, i32* %10
%299 = zext i32 %298 to i64
%300 = getelementptr inbounds float, float* %297, i64 %299
%301 = load float, float* %300
store float %301, float* %24
%302 = load float*, float** %17
%303 = load i32, i32* %11
%304 = zext i32 %303 to i64
%305 = getelementptr inbounds float, float* %302, i64 %304
%306 = load float, float* %305
store float %306, float* %25
%307 = load float*, float** %16
%308 = load i32, i32* %10
%309 = zext i32 %308 to i64
%310 = getelementptr inbounds float, float* %307, i64 %309
%311 = load float, float* %310
store float %311, float* %22
%312 = load float*, float** %16
%313 = load i32, i32* %11
%314 = zext i32 %313 to i64
%315 = getelementptr inbounds float, float* %312, i64 %314
%316 = load float, float* %315
store float %316, float* %23
%317 = load float, float* %32
%318 = load float*, float** %17
%319 = load i32, i32* %7
%320 = zext i32 %319 to i64
%321 = getelementptr inbounds float, float* %318, i64 %320
store float %317, float* %321
%322 = load float, float* %30
%323 = load float*, float** %16
%324 = load i32, i32* %7
%325 = zext i32 %324 to i64
%326 = getelementptr inbounds float, float* %323, i64 %325
store float %322, float* %326
%327 = load float, float* %33
%328 = load float*, float** %17
%329 = load i32, i32* %8
%330 = zext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
store float %327, float* %331
%332 = load float, float* %31
%333 = load float*, float** %16
%334 = load i32, i32* %8
%335 = zext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
store float %332, float* %336
%337 = load float, float* %34
%338 = load float*, float** %18
%339 = load i32, i32* %7
%340 = zext i32 %339 to i64
%341 = getelementptr inbounds float, float* %338, i64 %340
store float %337, float* %341
%342 = load float, float* %28
%343 = load float*, float** %15
%344 = load i32, i32* %7
%345 = zext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
store float %342, float* %346
%347 = load float, float* %35
%348 = load float*, float** %18
%349 = load i32, i32* %8
%350 = zext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
store float %347, float* %351
%352 = load float, float* %29
%353 = load float*, float** %15
%354 = load i32, i32* %8
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds float, float* %353, i64 %355
store float %352, float* %356
%357 = load float, float* %24
%358 = load float, float* %26
%359 = fadd float %357, %358
store float %359, float* %32
%360 = load float, float* %25
%361 = load float, float* %27
%362 = fadd float %360, %361
store float %362, float* %33
%363 = load float, float* %24
%364 = load float, float* %26
%365 = fsub float %363, %364
store float %365, float* %26
%366 = load float, float* %25
%367 = load float, float* %27
%368 = fsub float %366, %367
store float %368, float* %27
%369 = load float, float* %20
%370 = load float, float* %22
%371 = fsub float %369, %370
store float %371, float* %30
%372 = load float, float* %21
%373 = load float, float* %23
%374 = fsub float %372, %373
store float %374, float* %31
%375 = load float, float* %20
%376 = load float, float* %22
%377 = fadd float %375, %376
store float %377, float* %20
%378 = load float, float* %21
%379 = load float, float* %23
%380 = fadd float %378, %379
store float %380, float* %21
%381 = load i32, i32* %10
%382 = load float*, float** %18
%383 = zext i32 %381 to i64
%384 = getelementptr inbounds float, float* %382, i64 %383
store float* %384, float** %18
%385 = load i32, i32* %10
%386 = load float*, float** %15
%387 = zext i32 %385 to i64
%388 = getelementptr inbounds float, float* %386, i64 %387
store float* %388, float** %15
%389 = load i32, i32* %10
%390 = load float*, float** %16
%391 = zext i32 %389 to i64
%392 = getelementptr inbounds float, float* %390, i64 %391
store float* %392, float** %16
%393 = load i32, i32* %10
%394 = load float*, float** %17
%395 = zext i32 %393 to i64
%396 = getelementptr inbounds float, float* %394, i64 %395
store float* %396, float** %17
br label %397
397: ; preds = %118
%398 = load i32, i32* %13
%399 = add i32 %398, -1
store i32 %399, i32* %13
br label %115
400: ; preds = %115
%401 = load float, float* %30
%402 = load float, float* %27
%403 = fsub float %401, %402
store float %403, float* %34
%404 = load float, float* %31
%405 = load float, float* %26
%406 = fadd float %404, %405
store float %406, float* %35
%407 = load float, float* %30
%408 = load float, float* %27
%409 = fadd float %407, %408
store float %409, float* %30
%410 = load float, float* %31
%411 = load float, float* %26
%412 = fsub float %410, %411
store float %412, float* %31
%413 = load float, float* %20
%414 = load float, float* %32
%415 = fadd float %413, %414
store float %415, float* %28
%416 = load float, float* %21
%417 = load float, float* %33
%418 = fadd float %416, %417
store float %418, float* %29
%419 = load float, float* %20
%420 = load float, float* %32
%421 = fsub float %419, %420
store float %421, float* %32
%422 = load float, float* %21
%423 = load float, float* %33
%424 = fsub float %422, %423
store float %424, float* %33
%425 = load float*, float** %17
%426 = load i32, i32* %7
%427 = zext i32 %426 to i64
%428 = getelementptr inbounds float, float* %425, i64 %427
%429 = load float, float* %428
store float %429, float* %24
%430 = load float*, float** %17
%431 = load i32, i32* %8
%432 = zext i32 %431 to i64
%433 = getelementptr inbounds float, float* %430, i64 %432
%434 = load float, float* %433
store float %434, float* %25
%435 = load float*, float** %16
%436 = load i32, i32* %7
%437 = zext i32 %436 to i64
%438 = getelementptr inbounds float, float* %435, i64 %437
%439 = load float, float* %438
store float %439, float* %22
%440 = load float*, float** %16
%441 = load i32, i32* %8
%442 = zext i32 %441 to i64
%443 = getelementptr inbounds float, float* %440, i64 %442
%444 = load float, float* %443
store float %444, float* %23
%445 = load float*, float** %18
%446 = load i32, i32* %8
%447 = zext i32 %446 to i64
%448 = getelementptr inbounds float, float* %445, i64 %447
%449 = load float, float* %448
store float %449, float* %27
%450 = load float*, float** %15
%451 = load i32, i32* %7
%452 = zext i32 %451 to i64
%453 = getelementptr inbounds float, float* %450, i64 %452
%454 = load float, float* %453
store float %454, float* %20
%455 = load float*, float** %18
%456 = load i32, i32* %7
%457 = zext i32 %456 to i64
%458 = getelementptr inbounds float, float* %455, i64 %457
%459 = load float, float* %458
store float %459, float* %26
%460 = load float*, float** %15
%461 = load i32, i32* %8
%462 = zext i32 %461 to i64
%463 = getelementptr inbounds float, float* %460, i64 %462
%464 = load float, float* %463
store float %464, float* %21
%465 = load float, float* %34
%466 = load float*, float** %18
store float %465, float* %466
%467 = load float, float* %28
%468 = load float*, float** %15
store float %467, float* %468
%469 = load float, float* %35
%470 = load float*, float** %18
%471 = getelementptr inbounds float, float* %470, i64 1
store float %469, float* %471
%472 = load float, float* %29
%473 = load float*, float** %15
%474 = getelementptr inbounds float, float* %473, i64 1
store float %472, float* %474
%475 = load float, float* %30
%476 = load float*, float** %16
store float %475, float* %476
%477 = load float, float* %32
%478 = load float*, float** %17
store float %477, float* %478
%479 = load float, float* %31
%480 = load float*, float** %16
%481 = getelementptr inbounds float, float* %480, i64 1
store float %479, float* %481
%482 = load float, float* %33
%483 = load float*, float** %17
%484 = getelementptr inbounds float, float* %483, i64 1
store float %482, float* %484
%485 = load float, float* %24
%486 = load float, float* %27
%487 = fsub float %485, %486
store float %487, float* %34
%488 = load float, float* %25
%489 = load float, float* %26
%490 = fadd float %488, %489
store float %490, float* %35
%491 = load float, float* %24
%492 = load float, float* %27
%493 = fadd float %491, %492
store float %493, float* %24
%494 = load float, float* %25
%495 = load float, float* %26
%496 = fsub float %494, %495
store float %496, float* %25
%497 = load float, float* %20
%498 = load float, float* %23
%499 = fadd float %497, %498
store float %499, float* %28
%500 = load float, float* %21
%501 = load float, float* %22
%502 = fsub float %500, %501
store float %502, float* %29
%503 = load float, float* %20
%504 = load float, float* %23
%505 = fsub float %503, %504
store float %505, float* %36
%506 = load float, float* %21
%507 = load float, float* %22
%508 = fadd float %506, %507
store float %508, float* %37
%509 = load float, float* %36
%510 = load float, float* %34
%511 = load float, float* %19
%512 = fneg float %510
%513 = call float @llvm.fmuladd.f32(float %512, float %511, float %509)
%514 = load float, float* %35
%515 = load float, float* %19
%516 = call float @llvm.fmuladd.f32(float %514, float %515, float %513)
store float %516, float* %30
%517 = load float, float* %37
%518 = load float, float* %34
%519 = load float, float* %19
%520 = fneg float %518
%521 = call float @llvm.fmuladd.f32(float %520, float %519, float %517)
%522 = load float, float* %35
%523 = load float, float* %19
%524 = fneg float %522
%525 = call float @llvm.fmuladd.f32(float %524, float %523, float %521)
store float %525, float* %31
%526 = load float, float* %36
%527 = load float, float* %30
%528 = fneg float %527
%529 = call float @llvm.fmuladd.f32(float %526, float 2.000000e+00, float %528)
store float %529, float* %34
%530 = load float, float* %37
%531 = load float, float* %31
%532 = fneg float %531
%533 = call float @llvm.fmuladd.f32(float %530, float 2.000000e+00, float %532)
store float %533, float* %35
%534 = load float, float* %28
%535 = load float, float* %24
%536 = load float, float* %19
%537 = fneg float %535
%538 = call float @llvm.fmuladd.f32(float %537, float %536, float %534)
%539 = load float, float* %25
%540 = load float, float* %19
%541 = fneg float %539
%542 = call float @llvm.fmuladd.f32(float %541, float %540, float %538)
store float %542, float* %32
%543 = load float, float* %29
%544 = load float, float* %24
%545 = load float, float* %19
%546 = call float @llvm.fmuladd.f32(float %544, float %545, float %543)
%547 = load float, float* %25
%548 = load float, float* %19
%549 = fneg float %547
%550 = call float @llvm.fmuladd.f32(float %549, float %548, float %546)
store float %550, float* %33
%551 = load float, float* %28
%552 = load float, float* %32
%553 = fneg float %552
%554 = call float @llvm.fmuladd.f32(float %551, float 2.000000e+00, float %553)
store float %554, float* %28
%555 = load float, float* %29
%556 = load float, float* %33
%557 = fneg float %556
%558 = call float @llvm.fmuladd.f32(float %555, float 2.000000e+00, float %557)
store float %558, float* %29
%559 = load float, float* %32
%560 = load float*, float** %17
%561 = load i32, i32* %7
%562 = zext i32 %561 to i64
%563 = getelementptr inbounds float, float* %560, i64 %562
store float %559, float* %563
%564 = load float, float* %30
%565 = load float*, float** %16
%566 = load i32, i32* %7
%567 = zext i32 %566 to i64
%568 = getelementptr inbounds float, float* %565, i64 %567
store float %564, float* %568
%569 = load float, float* %33
%570 = load float*, float** %17
%571 = load i32, i32* %8
%572 = zext i32 %571 to i64
%573 = getelementptr inbounds float, float* %570, i64 %572
store float %569, float* %573
%574 = load float, float* %31
%575 = load float*, float** %16
%576 = load i32, i32* %8
%577 = zext i32 %576 to i64
%578 = getelementptr inbounds float, float* %575, i64 %577
store float %574, float* %578
%579 = load float, float* %34
%580 = load float*, float** %18
%581 = load i32, i32* %7
%582 = zext i32 %581 to i64
%583 = getelementptr inbounds float, float* %580, i64 %582
store float %579, float* %583
%584 = load float, float* %28
%585 = load float*, float** %15
%586 = load i32, i32* %7
%587 = zext i32 %586 to i64
%588 = getelementptr inbounds float, float* %585, i64 %587
store float %584, float* %588
%589 = load float, float* %35
%590 = load float*, float** %18
%591 = load i32, i32* %8
%592 = zext i32 %591 to i64
%593 = getelementptr inbounds float, float* %590, i64 %592
store float %589, float* %593
%594 = load float, float* %29
%595 = load float*, float** %15
%596 = load i32, i32* %8
%597 = zext i32 %596 to i64
%598 = getelementptr inbounds float, float* %595, i64 %597
store float %594, float* %598
ret void
}

LLVM IR (-O2):
define void @bfR4(float* nocapture %0, i32 %1, i32 %2) {
%4 = shl nsw i32 %2, 1
%5 = shl i32 %2, 3
%6 = zext i32 %1 to i64
%7 = shl nuw i64 1, %6
%8 = lshr i64 %7, 2
%9 = sext i32 %2 to i64
%10 = udiv i64 %8, %9
%11 = trunc i64 %10 to i32
%12 = zext i32 %4 to i64
%13 = getelementptr inbounds float, float* %0, i64 %12
%14 = getelementptr inbounds float, float* %13, i64 %12
%15 = getelementptr inbounds float, float* %14, i64 %12
%16 = load float, float* %0
%17 = load float, float* %13
%18 = load float, float* %14
%19 = load float, float* %15
%20 = getelementptr inbounds float, float* %0, i64 1
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %13, i64 1
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %14, i64 1
%25 = load float, float* %24
%26 = getelementptr inbounds float, float* %15, i64 1
%27 = load float, float* %26
%28 = fsub float %16, %17
%29 = fsub float %21, %23
%30 = fadd float %16, %17
%31 = fadd float %21, %23
%32 = fadd float %18, %19
%33 = fadd float %25, %27
%34 = fsub float %18, %19
%35 = fsub float %25, %27
%36 = add i32 %11, -1
%37 = icmp eq i32 %36, 0
br i1 %37, label %138, label %38
38: ; preds = %3
%39 = or i32 %5, 1
%40 = zext i32 %5 to i64
%41 = zext i32 %39 to i64
br label %42
42: ; preds = %38, %42
%43 = phi i32 [ %36, %38 ], [ %136, %42 ]
%44 = phi float [ %33, %38 ], [ %129, %42 ]
%45 = phi float [ %32, %38 ], [ %128, %42 ]
%46 = phi float [ %29, %38 ], [ %133, %42 ]
%47 = phi float [ %28, %38 ], [ %132, %42 ]
%48 = phi float [ %35, %38 ], [ %131, %42 ]
%49 = phi float [ %34, %38 ], [ %130, %42 ]
%50 = phi float [ %31, %38 ], [ %135, %42 ]
%51 = phi float [ %30, %38 ], [ %134, %42 ]
%52 = phi float* [ %0, %38 ], [ %114, %42 ]
%53 = phi float* [ %15, %38 ], [ %112, %42 ]
%54 = phi float* [ %14, %38 ], [ %120, %42 ]
%55 = phi float* [ %13, %38 ], [ %124, %42 ]
%56 = fsub float %47, %48
%57 = fadd float %49, %46
%58 = fadd float %48, %47
%59 = fsub float %46, %49
%60 = fadd float %51, %45
%61 = fadd float %50, %44
%62 = fsub float %51, %45
%63 = fsub float %50, %44
%64 = getelementptr inbounds float, float* %54, i64 2
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %54, i64 3
%67 = load float, float* %66
%68 = getelementptr inbounds float, float* %55, i64 2
%69 = load float, float* %68
%70 = getelementptr inbounds float, float* %55, i64 3
%71 = load float, float* %70
%72 = getelementptr inbounds float, float* %53, i64 3
%73 = load float, float* %72
%74 = getelementptr inbounds float, float* %52, i64 2
%75 = load float, float* %74
%76 = getelementptr inbounds float, float* %53, i64 2
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %52, i64 3
%79 = load float, float* %78
store float %56, float* %53
store float %60, float* %52
%80 = getelementptr inbounds float, float* %53, i64 1
store float %57, float* %80
%81 = getelementptr inbounds float, float* %52, i64 1
store float %61, float* %81
store float %58, float* %55
store float %62, float* %54
%82 = getelementptr inbounds float, float* %55, i64 1
store float %59, float* %82
%83 = getelementptr inbounds float, float* %54, i64 1
store float %63, float* %83
%84 = fsub float %65, %73
%85 = fadd float %67, %77
%86 = fadd float %65, %73
%87 = fsub float %67, %77
%88 = fadd float %71, %75
%89 = fsub float %79, %69
%90 = fsub float %75, %71
%91 = fadd float %69, %79
%92 = fneg float %84
%93 = tail call float @llvm.fmuladd.f32(float %92, float 0x3FE6A09E60000000, float %90)
%94 = tail call float @llvm.fmuladd.f32(float %85, float 0x3FE6A09E60000000, float %93)
%95 = tail call float @llvm.fmuladd.f32(float %92, float 0x3FE6A09E60000000, float %91)
%96 = fneg float %85
%97 = tail call float @llvm.fmuladd.f32(float %96, float 0x3FE6A09E60000000, float %95)
%98 = fneg float %94
%99 = tail call float @llvm.fmuladd.f32(float %90, float 2.000000e+00, float %98)
%100 = fneg float %97
%101 = tail call float @llvm.fmuladd.f32(float %91, float 2.000000e+00, float %100)
%102 = fneg float %86
%103 = tail call float @llvm.fmuladd.f32(float %102, float 0x3FE6A09E60000000, float %88)
%104 = fneg float %87
%105 = tail call float @llvm.fmuladd.f32(float %104, float 0x3FE6A09E60000000, float %103)
%106 = tail call float @llvm.fmuladd.f32(float %86, float 0x3FE6A09E60000000, float %89)
%107 = tail call float @llvm.fmuladd.f32(float %104, float 0x3FE6A09E60000000, float %106)
%108 = fneg float %105
%109 = tail call float @llvm.fmuladd.f32(float %88, float 2.000000e+00, float %108)
%110 = fneg float %107
%111 = tail call float @llvm.fmuladd.f32(float %89, float 2.000000e+00, float %110)
%112 = getelementptr inbounds float, float* %53, i64 %40
%113 = load float, float* %112
%114 = getelementptr inbounds float, float* %52, i64 %40
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %53, i64 %41
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %52, i64 %41
%119 = load float, float* %118
%120 = getelementptr inbounds float, float* %54, i64 %40
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %54, i64 %41
%123 = load float, float* %122
%124 = getelementptr inbounds float, float* %55, i64 %40
%125 = load float, float* %124
%126 = getelementptr inbounds float, float* %55, i64 %41
%127 = load float, float* %126
store float %105, float* %64
store float %94, float* %68
store float %107, float* %66
store float %97, float* %70
store float %99, float* %76
store float %109, float* %74
store float %101, float* %72
store float %111, float* %78
%128 = fadd float %113, %121
%129 = fadd float %117, %123
%130 = fsub float %121, %113
%131 = fsub float %123, %117
%132 = fsub float %115, %125
%133 = fsub float %119, %127
%134 = fadd float %115, %125
%135 = fadd float %119, %127
%136 = add i32 %43, -1
%137 = icmp eq i32 %136, 0
br i1 %137, label %138, label %42
138: ; preds = %42, %3
%139 = phi float* [ %13, %3 ], [ %124, %42 ]
%140 = phi float* [ %14, %3 ], [ %120, %42 ]
%141 = phi float* [ %15, %3 ], [ %112, %42 ]
%142 = phi float* [ %0, %3 ], [ %114, %42 ]
%143 = phi float [ %30, %3 ], [ %134, %42 ]
%144 = phi float [ %31, %3 ], [ %135, %42 ]
%145 = phi float [ %34, %3 ], [ %130, %42 ]
%146 = phi float [ %35, %3 ], [ %131, %42 ]
%147 = phi float [ %28, %3 ], [ %132, %42 ]
%148 = phi float [ %29, %3 ], [ %133, %42 ]
%149 = phi float [ %32, %3 ], [ %128, %42 ]
%150 = phi float [ %33, %3 ], [ %129, %42 ]
%151 = fsub float %147, %146
%152 = fadd float %145, %148
%153 = fadd float %146, %147
%154 = fsub float %148, %145
%155 = fadd float %143, %149
%156 = fadd float %144, %150
%157 = fsub float %143, %149
%158 = fsub float %144, %150
%159 = getelementptr inbounds float, float* %140, i64 2
%160 = load float, float* %159
%161 = getelementptr inbounds float, float* %140, i64 3
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %139, i64 2
%164 = load float, float* %163
%165 = getelementptr inbounds float, float* %139, i64 3
%166 = load float, float* %165
%167 = getelementptr inbounds float, float* %141, i64 3
%168 = load float, float* %167
%169 = getelementptr inbounds float, float* %142, i64 2
%170 = load float, float* %169
%171 = getelementptr inbounds float, float* %141, i64 2
%172 = load float, float* %171
%173 = getelementptr inbounds float, float* %142, i64 3
%174 = load float, float* %173
store float %151, float* %141
store float %155, float* %142
%175 = getelementptr inbounds float, float* %141, i64 1
store float %152, float* %175
%176 = getelementptr inbounds float, float* %142, i64 1
store float %156, float* %176
store float %153, float* %139
store float %157, float* %140
%177 = getelementptr inbounds float, float* %139, i64 1
store float %154, float* %177
%178 = getelementptr inbounds float, float* %140, i64 1
store float %158, float* %178
%179 = fsub float %160, %168
%180 = fadd float %162, %172
%181 = fadd float %160, %168
%182 = fsub float %162, %172
%183 = fadd float %166, %170
%184 = fsub float %174, %164
%185 = fsub float %170, %166
%186 = fadd float %164, %174
%187 = fneg float %179
%188 = tail call float @llvm.fmuladd.f32(float %187, float 0x3FE6A09E60000000, float %185)
%189 = tail call float @llvm.fmuladd.f32(float %180, float 0x3FE6A09E60000000, float %188)
%190 = tail call float @llvm.fmuladd.f32(float %187, float 0x3FE6A09E60000000, float %186)
%191 = fneg float %180
%192 = tail call float @llvm.fmuladd.f32(float %191, float 0x3FE6A09E60000000, float %190)
%193 = fneg float %189
%194 = tail call float @llvm.fmuladd.f32(float %185, float 2.000000e+00, float %193)
%195 = fneg float %192
%196 = tail call float @llvm.fmuladd.f32(float %186, float 2.000000e+00, float %195)
%197 = fneg float %181
%198 = tail call float @llvm.fmuladd.f32(float %197, float 0x3FE6A09E60000000, float %183)
%199 = fneg float %182
%200 = tail call float @llvm.fmuladd.f32(float %199, float 0x3FE6A09E60000000, float %198)
%201 = tail call float @llvm.fmuladd.f32(float %181, float 0x3FE6A09E60000000, float %184)
%202 = tail call float @llvm.fmuladd.f32(float %199, float 0x3FE6A09E60000000, float %201)
%203 = fneg float %200
%204 = tail call float @llvm.fmuladd.f32(float %183, float 2.000000e+00, float %203)
%205 = fneg float %202
%206 = tail call float @llvm.fmuladd.f32(float %184, float 2.000000e+00, float %205)
store float %200, float* %159
store float %189, float* %163
store float %202, float* %161
store float %192, float* %165
store float %194, float* %171
store float %204, float* %169
store float %196, float* %167
store float %206, float* %173
ret void
}