#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void bfR2(float *ioptr, int M, int NDiffU) {
  unsigned int pos;
  unsigned int posi;
  unsigned int pinc;
  unsigned int pnext;
  unsigned int NSameU;
  unsigned int 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;
  pinc = NDiffU * 2;
  pnext = pinc * 4;
  pos = 2;
  posi = pos + 1;
  NSameU = ((uint32_t)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):
<bfR2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x20(%rbp)
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cltd
idivl  -0x10(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%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    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jbe    1509 <bfR2+0x409>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x68(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x58(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x58(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x64(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x68(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%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    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1199 <bfR2+0x99>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bfR2>:
mov    %edx,%r8d
mov    %esi,%ecx
mov    $0x1,%edx
shl    %cl,%edx
lea    0x3(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
sar    $0x2,%eax
cltd
idiv   %r8d
test   %eax,%eax
je     1260 <bfR2+0x160>
lea    (%r8,%r8,1),%ecx
shl    $0x3,%r8d
add    $0xc,%rdi
shl    $0x2,%r8
lea    0x0(,%rcx,4),%rdx
lea    (%rdx,%rdx,2),%rdx
nop
movss  -0xc(%rdi),%xmm0
movss  -0x8(%rdi),%xmm6
movss  -0xc(%rdi,%rcx,4),%xmm2
movss  -0x8(%rdi,%rcx,4),%xmm3
movss  -0xc(%rdi,%rcx,8),%xmm4
movss  -0x8(%rdi,%rcx,8),%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,4)
movss  %xmm6,-0x8(%rdi,%rcx,4)
movss  %xmm2,-0xc(%rdi,%rcx,8)
movss  %xmm3,-0x8(%rdi,%rcx,8)
movss  %xmm4,-0xc(%rdi,%rdx,1)
movss  %xmm5,-0x8(%rdi,%rdx,1)
movss  -0x4(%rdi,%rcx,4),%xmm0
movss  (%rdi,%rcx,4),%xmm1
movss  -0x4(%rdi),%xmm2
movss  (%rdi),%xmm3
movss  -0x4(%rdi,%rdx,1),%xmm8
movss  (%rdi,%rdx,1),%xmm9
movss  -0x4(%rdi,%rcx,8),%xmm6
movss  (%rdi,%rcx,8),%xmm7
movaps %xmm2,%xmm4
addss  %xmm1,%xmm4
movaps %xmm3,%xmm5
subss  %xmm0,%xmm5
subss  %xmm1,%xmm2
addss  %xmm0,%xmm3
movaps %xmm6,%xmm0
addss  %xmm9,%xmm0
movaps %xmm7,%xmm1
subss  %xmm8,%xmm1
subss  %xmm9,%xmm6
addss  %xmm8,%xmm7
movss  %xmm4,-0x4(%rdi)
movss  %xmm5,(%rdi)
movss  %xmm2,-0x4(%rdi,%rcx,4)
movss  %xmm3,(%rdi,%rcx,4)
movss  %xmm0,-0x4(%rdi,%rcx,8)
movss  %xmm1,(%rdi,%rcx,8)
movss  %xmm6,-0x4(%rdi,%rdx,1)
movss  %xmm7,(%rdi,%rdx,1)
add    %r8,%rdi
add    $0xffffffff,%eax
jne    1140 <bfR2+0x40>
ret

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

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