void ibfR2(float *ioptr, long M, long NDiffU) {
  unsigned long pos;
  unsigned long posi;
  unsigned long pinc;
  unsigned long pnext;
  unsigned long NSameU;
  unsigned long SameUCnt;
  float *pstrt;
  float *p0r, *p1r, *p2r, *p3r;
  float f0r, f0i, f1r, f1i, f2r, f2i, f3r, f3i;
  float f4r, f4i, f5r, f5i, f6r, f6i, f7r, f7i;
  const float Two = 2.0;
  pinc = NDiffU * 2;
  pnext = pinc * 4;
  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;
  for (SameUCnt = NSameU; SameUCnt > 0; SameUCnt--) {
    f0r = *p0r;
    f1r = *p1r;
    f0i = *(p0r + 1);
    f1i = *(p1r + 1);
    f2r = *p2r;
    f3r = *p3r;
    f2i = *(p2r + 1);
    f3i = *(p3r + 1);
    f4r = f0r + f1r;
    f4i = f0i + f1i;
    f5r = f0r - f1r;
    f5i = f0i - f1i;
    f6r = f2r + f3r;
    f6i = f2i + f3i;
    f7r = f2r - f3r;
    f7i = f2i - f3i;
    *p0r = f4r;
    *(p0r + 1) = f4i;
    *p1r = f5r;
    *(p1r + 1) = f5i;
    *p2r = f6r;
    *(p2r + 1) = f6i;
    *p3r = f7r;
    *(p3r + 1) = f7i;
    f0r = *(p0r + pos);
    f1i = *(p1r + posi);
    f0i = *(p0r + posi);
    f1r = *(p1r + pos);
    f2r = *(p2r + pos);
    f3i = *(p3r + posi);
    f2i = *(p2r + posi);
    f3r = *(p3r + pos);
    f4r = f0r - f1i;
    f4i = f0i + f1r;
    f5r = f0r + f1i;
    f5i = f0i - f1r;
    f6r = f2r - f3i;
    f6i = f2i + f3r;
    f7r = f2r + f3i;
    f7i = f2i - f3r;
    *(p0r + pos) = f4r;
    *(p0r + posi) = f4i;
    *(p1r + pos) = f5r;
    *(p1r + posi) = f5i;
    *(p2r + pos) = f6r;
    *(p2r + posi) = f6i;
    *(p3r + pos) = f7r;
    *(p3r + posi) = f7i;
    p0r += pnext;
    p1r += pnext;
    p2r += pnext;
    p3r += pnext;
  }
}


x86 assembly (clang, -O0):
<ibfR2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  0xee4(%rip),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x18(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x38(%rbp)
movq   $0x2,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rcx
mov    $0x1,%eax
shl    %cl,%rax
shr    $0x2,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jbe    15a9 <ibfR2+0x4a9>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x70(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x68(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x70(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x74(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x78(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x78(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xac(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
shl    $0x2,%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x2,%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x2,%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x2,%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    11bd <ibfR2+0xbd>
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ibfR2>:
mov    %rsi,%rcx
mov    $0x1,%eax
shl    %cl,%rax
shr    $0x2,%rax
cmp    %rdx,%rax
jb     1271 <ibfR2+0x171>
mov    %rdx,%rcx
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
je     112e <ibfR2+0x2e>
xor    %edx,%edx
div    %rcx
jmp    1132 <ibfR2+0x32>
xor    %edx,%edx
div    %ecx
add    $0xc,%rdi
mov    %rcx,%r8
shl    $0x5,%r8
mov    %rcx,%rsi
shl    $0x4,%rsi
lea    0x0(,%rcx,8),%rdx
lea    (%rdx,%rdx,2),%rdx
movss  -0xc(%rdi),%xmm0
movss  -0x8(%rdi),%xmm6
movss  -0xc(%rdi,%rcx,8),%xmm2
movss  -0x8(%rdi,%rcx,8),%xmm3
movss  -0xc(%rdi,%rsi,1),%xmm4
movss  -0x8(%rdi,%rsi,1),%xmm5
movss  -0xc(%rdi,%rdx,1),%xmm9
movss  -0x8(%rdi,%rdx,1),%xmm8
movaps %xmm0,%xmm7
addss  %xmm2,%xmm7
movaps %xmm6,%xmm1
addss  %xmm3,%xmm1
subss  %xmm2,%xmm0
subss  %xmm3,%xmm6
movaps %xmm4,%xmm2
addss  %xmm9,%xmm2
movaps %xmm5,%xmm3
addss  %xmm8,%xmm3
subss  %xmm9,%xmm4
subss  %xmm8,%xmm5
movss  %xmm7,-0xc(%rdi)
movss  %xmm1,-0x8(%rdi)
movss  %xmm0,-0xc(%rdi,%rcx,8)
movss  %xmm6,-0x8(%rdi,%rcx,8)
movss  %xmm2,-0xc(%rdi,%rsi,1)
movss  %xmm3,-0x8(%rdi,%rsi,1)
movss  %xmm4,-0xc(%rdi,%rdx,1)
movss  %xmm5,-0x8(%rdi,%rdx,1)
movss  -0x4(%rdi,%rcx,8),%xmm0
movss  (%rdi,%rcx,8),%xmm1
movss  -0x4(%rdi),%xmm2
movss  (%rdi),%xmm3
movss  -0x4(%rdi,%rdx,1),%xmm8
movss  (%rdi,%rdx,1),%xmm9
movss  -0x4(%rdi,%rsi,1),%xmm6
movss  (%rdi,%rsi,1),%xmm7
movaps %xmm2,%xmm4
subss  %xmm1,%xmm4
movaps %xmm3,%xmm5
addss  %xmm0,%xmm5
addss  %xmm1,%xmm2
subss  %xmm0,%xmm3
movaps %xmm6,%xmm0
subss  %xmm9,%xmm0
movaps %xmm7,%xmm1
addss  %xmm8,%xmm1
addss  %xmm9,%xmm6
subss  %xmm8,%xmm7
movss  %xmm4,-0x4(%rdi)
movss  %xmm5,(%rdi)
movss  %xmm2,-0x4(%rdi,%rcx,8)
movss  %xmm3,(%rdi,%rcx,8)
movss  %xmm0,-0x4(%rdi,%rsi,1)
movss  %xmm1,(%rdi,%rsi,1)
movss  %xmm6,-0x4(%rdi,%rdx,1)
movss  %xmm7,(%rdi,%rdx,1)
add    %r8,%rdi
add    $0xffffffffffffffff,%rax
jne    1150 <ibfR2+0x50>
ret

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

LLVM IR (-O2):
define void @ibfR2(float* nocapture %0, i64 %1, i64 %2) {
%4 = shl nsw i64 %2, 1
%5 = shl i64 %2, 3
%6 = shl nuw i64 1, %1
%7 = lshr i64 %6, 2
%8 = getelementptr inbounds float, float* %0, i64 %4
%9 = getelementptr inbounds float, float* %8, i64 %4
%10 = icmp ult i64 %7, %2
br i1 %10, label %70, label %11
11: ; preds = %3
%12 = getelementptr inbounds float, float* %9, i64 %4
%13 = udiv i64 %7, %2
br label %14
14: ; preds = %11, %14
%15 = phi i64 [ %68, %14 ], [ %13, %11 ]
%16 = phi float* [ %64, %14 ], [ %0, %11 ]
%17 = phi float* [ %65, %14 ], [ %8, %11 ]
%18 = phi float* [ %66, %14 ], [ %9, %11 ]
%19 = phi float* [ %67, %14 ], [ %12, %11 ]
%20 = load float, float* %16
%21 = load float, float* %17
%22 = getelementptr inbounds float, float* %16, i64 1
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %17, i64 1
%25 = load float, float* %24
%26 = load float, float* %18
%27 = load float, float* %19
%28 = getelementptr inbounds float, float* %18, i64 1
%29 = load float, float* %28
%30 = getelementptr inbounds float, float* %19, i64 1
%31 = load float, float* %30
%32 = fadd float %20, %21
%33 = fadd float %23, %25
%34 = fsub float %20, %21
%35 = fsub float %23, %25
%36 = fadd float %26, %27
%37 = fadd float %29, %31
%38 = fsub float %26, %27
%39 = fsub float %29, %31
store float %32, float* %16
store float %33, float* %22
store float %34, float* %17
store float %35, float* %24
store float %36, float* %18
store float %37, float* %28
store float %38, float* %19
store float %39, float* %30
%40 = getelementptr inbounds float, float* %16, i64 2
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %17, i64 3
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %16, i64 3
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %17, i64 2
%47 = load float, float* %46
%48 = getelementptr inbounds float, float* %18, i64 2
%49 = load float, float* %48
%50 = getelementptr inbounds float, float* %19, i64 3
%51 = load float, float* %50
%52 = getelementptr inbounds float, float* %18, i64 3
%53 = load float, float* %52
%54 = getelementptr inbounds float, float* %19, i64 2
%55 = load float, float* %54
%56 = fsub float %41, %43
%57 = fadd float %45, %47
%58 = fadd float %41, %43
%59 = fsub float %45, %47
%60 = fsub float %49, %51
%61 = fadd float %53, %55
%62 = fadd float %49, %51
%63 = fsub float %53, %55
store float %56, float* %40
store float %57, float* %44
store float %58, float* %46
store float %59, float* %42
store float %60, float* %48
store float %61, float* %52
store float %62, float* %54
store float %63, float* %50
%64 = getelementptr inbounds float, float* %16, i64 %5
%65 = getelementptr inbounds float, float* %17, i64 %5
%66 = getelementptr inbounds float, float* %18, i64 %5
%67 = getelementptr inbounds float, float* %19, i64 %5
%68 = add i64 %15, -1
%69 = icmp eq i64 %68, 0
br i1 %69, label %70, label %14
70: ; preds = %14, %3
ret void
}