void bitrv2(int n, int *ip, float *a) {
  int j, j1, k, k1, l, m, m2;
  float xr, xi;
  ip[0] = 0;
  l = n;
  m = 1;
  while ((m << 2) < l) {
    l >>= 1;
    for (j = 0; j <= m - 1; j++) {
      ip[m + j] = ip[j] + l;
    }
    m <<= 1;
  }
  if ((m << 2) > l) {
    for (k = 1; k <= m - 1; k++) {
      for (j = 0; j <= k - 1; j++) {
        j1 = (j << 1) + ip[k];
        k1 = (k << 1) + ip[j];
        xr = a[j1];
        xi = a[j1 + 1];
        a[j1] = a[k1];
        a[j1 + 1] = a[k1 + 1];
        a[k1] = xr;
        a[k1 + 1] = xi;
      }
    }
  } else {
    m2 = m << 1;
    for (k = 1; k <= m - 1; k++) {
      for (j = 0; j <= k - 1; j++) {
        j1 = (j << 1) + ip[k];
        k1 = (k << 1) + ip[j];
        xr = a[j1];
        xi = a[j1 + 1];
        a[j1] = a[k1];
        a[j1 + 1] = a[k1 + 1];
        a[k1] = xr;
        a[k1 + 1] = xi;
        j1 += m2;
        k1 += m2;
        xr = a[j1];
        xi = a[j1 + 1];
        a[j1] = a[k1];
        a[j1 + 1] = a[k1 + 1];
        a[k1] = xr;
        a[k1 + 1] = xi;
      }
    }
  }
}


x86 assembly (clang, -O0):
<bitrv2>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
cmp    -0x2c(%rbp),%eax
jge    1190 <bitrv2+0x90>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1182 <bitrv2+0x82>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1145 <bitrv2+0x45>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1126 <bitrv2+0x26>
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
cmp    -0x2c(%rbp),%eax
jle    12ad <bitrv2+0x1ad>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12a8 <bitrv2+0x1a8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1295 <bitrv2+0x195>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11be <bitrv2+0xbe>
jmp    129a <bitrv2+0x19a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a6 <bitrv2+0xa6>
jmp    1466 <bitrv2+0x366>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1461 <bitrv2+0x361>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     144e <bitrv2+0x34e>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d5 <bitrv2+0x1d5>
jmp    1453 <bitrv2+0x353>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12bd <bitrv2+0x1bd>
jmp    1466 <bitrv2+0x366>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2>:
push   %rbp
push   %r14
push   %rbx
movl   $0x0,(%rsi)
cmp    $0x5,%edi
jl     139a <bitrv2+0x29a>
lea    0x30(%rsi),%r11
mov    $0x1,%eax
jmp    1134 <bitrv2+0x34>
xchg   %ax,%ax
lea    (%r8,%r8,1),%eax
lea    0x0(,%r8,8),%ecx
cmp    %edi,%ecx
jge    1240 <bitrv2+0x140>
mov    %eax,%r8d
sar    %edi
test   %eax,%eax
jle    1120 <bitrv2+0x20>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    1150 <bitrv2+0x50>
xor    %eax,%eax
jmp    1210 <bitrv2+0x110>
nopl   (%rax)
mov    %r9d,%eax
and    $0xfffffff8,%eax
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1236 <bitrv2+0x136>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r11,%r9,4),%r14
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x30(%r11,%rcx,4),%xmm1
movdqu -0x20(%r11,%rcx,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%r14,%rcx,4)
movdqu %xmm2,-0x20(%r14,%rcx,4)
movdqu -0x10(%r11,%rcx,4),%xmm1
movdqu (%r11,%rcx,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x10(%r14,%rcx,4)
movdqu %xmm2,(%r14,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1190 <bitrv2+0x90>
test   $0x1,%r10b
je     1207 <bitrv2+0x107>
movdqu (%rsi,%rcx,4),%xmm1
movdqu 0x10(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
add    %r9,%rcx
movdqu %xmm1,(%rsi,%rcx,4)
movdqu %xmm2,0x10(%rsi,%rcx,4)
cmp    %r9,%rax
je     1120 <bitrv2+0x20>
lea    (%rsi,%r9,4),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rax,4),%ebx
add    %edi,%ebx
mov    %ebx,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1220 <bitrv2+0x120>
jmp    1120 <bitrv2+0x20>
xor    %ecx,%ecx
test   $0x1,%r10b
jne    11e6 <bitrv2+0xe6>
jmp    1207 <bitrv2+0x107>
jle    12cb <bitrv2+0x1cb>
cmp    $0x2,%eax
jl     139a <bitrv2+0x29a>
mov    %eax,%r8d
mov    $0x1,%r9d
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%r9,4),%eax
lea    (%r9,%r9,1),%r10d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movslq (%rsi,%rbx,4),%rcx
movslq %r10d,%rdi
add    %rcx,%rdi
cltq
movd   (%rdx,%rax,4),%xmm0
lea    0x1(%rax),%ecx
movslq %ecx,%r11
movd   (%rdx,%r11,4),%xmm1
movss  (%rdx,%rdi,4),%xmm2
movss  %xmm2,(%rdx,%rax,4)
movslq %edi,%rcx
movd   0x4(%rdx,%rcx,4),%xmm2
movd   %xmm2,(%rdx,%r11,4)
movd   %xmm0,(%rdx,%rdi,4)
movd   %xmm1,0x4(%rdx,%rcx,4)
add    $0x1,%rbx
add    $0x2,%eax
cmp    %rbx,%r9
jne    1270 <bitrv2+0x170>
add    $0x1,%r9
cmp    %r8,%r9
jne    1260 <bitrv2+0x160>
jmp    139a <bitrv2+0x29a>
cmp    $0x2,%eax
jl     139a <bitrv2+0x29a>
shl    $0x2,%r8d
mov    %eax,%r9d
mov    $0x1,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%r11,4),%ecx
lea    (%r11,%r11,1),%r10d
lea    (%r8,%rcx,1),%r14d
xor    %eax,%eax
xchg   %ax,%ax
movslq (%rsi,%rax,4),%rbx
movslq %r10d,%rdi
add    %rbx,%rdi
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm0
lea    0x1(%rcx),%ebx
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm1
movss  (%rdx,%rdi,4),%xmm2
movss  %xmm2,(%rdx,%rcx,4)
movslq %edi,%rbp
movss  0x4(%rdx,%rbp,4),%xmm2
movss  %xmm2,(%rdx,%rbx,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  %xmm1,0x4(%rdx,%rbp,4)
add    %r8d,%ebp
movslq %r14d,%rdi
movd   (%rdx,%rdi,4),%xmm0
lea    0x1(%rdi),%ebx
movslq %ebx,%rbx
movd   (%rdx,%rbx,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  %xmm2,(%rdx,%rdi,4)
movd   0x4(%rdx,%rbp,4),%xmm2
movd   %xmm2,(%rdx,%rbx,4)
movd   %xmm0,(%rdx,%rbp,4)
movd   %xmm1,0x4(%rdx,%rbp,4)
add    $0x1,%rax
lea    0x2(%rdi),%r14d
add    $0x2,%ecx
cmp    %rax,%r11
jne    1300 <bitrv2+0x200>
add    $0x1,%r11
cmp    %r9,%r11
jne    12f0 <bitrv2+0x1f0>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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