void bitrv2_128_C(float *a) {
  unsigned int j, j1, k, k1;
  float xr, xi, yr, yi;
  static const int ip[4] = {0, 64, 32, 96};
  for (k = 0; k < 4; k++) {
    for (j = 0; j < k; j++) {
      j1 = 2 * j + ip[k];
      k1 = 2 * k + ip[j];
      xr = a[j1 + 0];
      xi = a[j1 + 1];
      yr = a[k1 + 0];
      yi = a[k1 + 1];
      a[j1 + 0] = yr;
      a[j1 + 1] = yi;
      a[k1 + 0] = xr;
      a[k1 + 1] = xi;
      j1 += 8;
      k1 += 16;
      xr = a[j1 + 0];
      xi = a[j1 + 1];
      yr = a[k1 + 0];
      yi = a[k1 + 1];
      a[j1 + 0] = yr;
      a[j1 + 1] = yi;
      a[k1 + 0] = xr;
      a[k1 + 1] = xi;
      j1 += 8;
      k1 -= 8;
      xr = a[j1 + 0];
      xi = a[j1 + 1];
      yr = a[k1 + 0];
      yi = a[k1 + 1];
      a[j1 + 0] = yr;
      a[j1 + 1] = yi;
      a[k1 + 0] = xr;
      a[k1 + 1] = xi;
      j1 += 8;
      k1 += 16;
      xr = a[j1 + 0];
      xi = a[j1 + 1];
      yr = a[k1 + 0];
      yi = a[k1 + 1];
      a[j1 + 0] = yr;
      a[j1 + 1] = yi;
      a[k1 + 0] = xr;
      a[k1 + 1] = xi;
    }
    j1 = 2 * k + 8 + ip[k];
    k1 = j1 + 8;
    xr = a[j1 + 0];
    xi = a[j1 + 1];
    yr = a[k1 + 0];
    yi = a[k1 + 1];
    a[j1 + 0] = yr;
    a[j1 + 1] = yi;
    a[k1 + 0] = xr;
    a[k1 + 1] = xi;
  }
}


x86 assembly (clang, -O0):
<bitrv2_128_C>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jae    1542 <bitrv2_128_C+0x442>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1460 <bitrv2_128_C+0x360>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
lea    0xec2(%rip),%rcx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    -0xc(%rbp),%ecx
mov    %ecx,%edx
lea    0xeaa(%rip),%rcx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1120 <bitrv2_128_C+0x20>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x8,%eax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
lea    0xb8b(%rip),%rcx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    110f <bitrv2_128_C+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2_128_C>:
push   %r15
push   %r14
push   %r12
push   %rbx
xor    %r10d,%r10d
lea    0xeef(%rip),%r9
xor    %r8d,%r8d
jmp    1176 <bitrv2_128_C+0x76>
cs nopw 0x0(%rax,%rax,1)
xor    %r11d,%r11d
xor    %r14d,%r14d
lea    (%r11,%r14,1),%eax
add    $0x8,%eax
lea    0x10(%r11,%r14,1),%ecx
movss  (%rdi,%rax,4),%xmm0
lea    0x9(%r11,%r14,1),%edx
movss  (%rdi,%rdx,4),%xmm1
movss  (%rdi,%rcx,4),%xmm2
lea    0x11(%r11,%r14,1),%esi
movss  (%rdi,%rsi,4),%xmm3
movss  %xmm2,(%rdi,%rax,4)
movss  %xmm3,(%rdi,%rdx,4)
movss  %xmm0,(%rdi,%rcx,4)
movss  %xmm1,(%rdi,%rsi,4)
add    $0x1,%r8
add    $0x4,%r10
cmp    $0x4,%r8
je     129f <bitrv2_128_C+0x19f>
test   %r8,%r8
je     1120 <bitrv2_128_C+0x20>
mov    (%r9,%r8,4),%r14d
lea    (%r8,%r8,1),%r11
xor    %r12d,%r12d
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rax,1),%r15d
mov    (%r12,%r9,1),%edx
lea    (%rdx,%r11,1),%esi
movss  (%rdi,%r15,4),%xmm0
lea    (%r14,%rax,1),%ebx
add    $0x1,%ebx
movss  (%rdi,%rbx,4),%xmm1
movss  (%rdi,%rsi,4),%xmm2
lea    0x1(%rdx,%r11,1),%ecx
movss  (%rdi,%rcx,4),%xmm3
movss  %xmm2,(%rdi,%r15,4)
movss  %xmm3,(%rdi,%rbx,4)
movss  %xmm0,(%rdi,%rsi,4)
movss  %xmm1,(%rdi,%rcx,4)
lea    0x8(%r14,%rax,1),%ecx
lea    0x10(%rdx,%r11,1),%r15d
movss  (%rdi,%rcx,4),%xmm0
lea    0x9(%r14,%rax,1),%ebx
movss  (%rdi,%rbx,4),%xmm1
movss  (%rdi,%r15,4),%xmm2
lea    0x11(%rdx,%r11,1),%esi
movss  (%rdi,%rsi,4),%xmm3
movss  %xmm2,(%rdi,%rcx,4)
movss  %xmm3,(%rdi,%rbx,4)
movss  %xmm0,(%rdi,%r15,4)
movss  %xmm1,(%rdi,%rsi,4)
lea    0x10(%r14,%rax,1),%ecx
lea    0x8(%rdx,%r11,1),%r15d
movss  (%rdi,%rcx,4),%xmm0
lea    0x11(%r14,%rax,1),%ebx
movss  (%rdi,%rbx,4),%xmm1
movss  (%rdi,%r15,4),%xmm2
lea    0x9(%rdx,%r11,1),%esi
movss  (%rdi,%rsi,4),%xmm3
movss  %xmm2,(%rdi,%rcx,4)
movss  %xmm3,(%rdi,%rbx,4)
movss  %xmm0,(%rdi,%r15,4)
movss  %xmm1,(%rdi,%rsi,4)
lea    0x18(%r14,%rax,1),%ecx
lea    0x18(%rdx,%r11,1),%esi
movss  (%rdi,%rcx,4),%xmm0
lea    0x19(%r14,%rax,1),%ebx
movss  (%rdi,%rbx,4),%xmm1
movss  (%rdi,%rsi,4),%xmm2
lea    0x19(%rdx,%r11,1),%edx
movss  (%rdi,%rdx,4),%xmm3
movss  %xmm2,(%rdi,%rcx,4)
movss  %xmm3,(%rdi,%rbx,4)
movss  %xmm0,(%rdi,%rsi,4)
movss  %xmm1,(%rdi,%rdx,4)
add    $0x2,%eax
add    $0x4,%r12
cmp    %r12,%r10
jne    1190 <bitrv2_128_C+0x90>
jmp    1126 <bitrv2_128_C+0x26>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@bitrv2_128_C.ip = internal unnamed_addr constant [4 x i32] [i32 0, i32 64, i32 32, i32 96]
define void @bitrv2_128_C(float* nocapture %0) {
br label %2
2: ; preds = %1, %82
%3 = phi i64 [ 0, %1 ], [ %103, %82 ]
%4 = icmp eq i64 %3, 0
br i1 %4, label %82, label %5
5: ; preds = %2
%6 = getelementptr inbounds [4 x i32], [4 x i32]* @bitrv2_128_C.ip, i64 0, i64 %3
%7 = load i32, i32* %6
%8 = shl nuw i64 %3, 1
%9 = trunc i64 %8 to i32
br label %10
10: ; preds = %5, %10
%11 = phi i64 [ 0, %5 ], [ %80, %10 ]
%12 = trunc i64 %11 to i32
%13 = shl i32 %12, 1
%14 = add i32 %7, %13
%15 = getelementptr inbounds [4 x i32], [4 x i32]* @bitrv2_128_C.ip, i64 0, i64 %11
%16 = load i32, i32* %15
%17 = add i32 %16, %9
%18 = zext i32 %14 to i64
%19 = getelementptr inbounds float, float* %0, i64 %18
%20 = load float, float* %19
%21 = add i32 %14, 1
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds float, float* %0, i64 %22
%24 = load float, float* %23
%25 = zext i32 %17 to i64
%26 = getelementptr inbounds float, float* %0, i64 %25
%27 = load float, float* %26
%28 = add i32 %17, 1
%29 = zext i32 %28 to i64
%30 = getelementptr inbounds float, float* %0, i64 %29
%31 = load float, float* %30
store float %27, float* %19
store float %31, float* %23
store float %20, float* %26
store float %24, float* %30
%32 = add i32 %14, 8
%33 = add i32 %17, 16
%34 = zext i32 %32 to i64
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = load float, float* %35
%37 = add i32 %14, 9
%38 = zext i32 %37 to i64
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = load float, float* %39
%41 = zext i32 %33 to i64
%42 = getelementptr inbounds float, float* %0, i64 %41
%43 = load float, float* %42
%44 = add i32 %17, 17
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds float, float* %0, i64 %45
%47 = load float, float* %46
store float %43, float* %35
store float %47, float* %39
store float %36, float* %42
store float %40, float* %46
%48 = add i32 %14, 16
%49 = add i32 %17, 8
%50 = zext i32 %48 to i64
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = add i32 %14, 17
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = zext i32 %49 to i64
%58 = getelementptr inbounds float, float* %0, i64 %57
%59 = load float, float* %58
%60 = add i32 %17, 9
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds float, float* %0, i64 %61
%63 = load float, float* %62
store float %59, float* %51
store float %63, float* %55
store float %52, float* %58
store float %56, float* %62
%64 = add i32 %14, 24
%65 = add i32 %17, 24
%66 = zext i32 %64 to i64
%67 = getelementptr inbounds float, float* %0, i64 %66
%68 = load float, float* %67
%69 = add i32 %14, 25
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds float, float* %0, i64 %70
%72 = load float, float* %71
%73 = zext i32 %65 to i64
%74 = getelementptr inbounds float, float* %0, i64 %73
%75 = load float, float* %74
%76 = add i32 %17, 25
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds float, float* %0, i64 %77
%79 = load float, float* %78
store float %75, float* %67
store float %79, float* %71
store float %68, float* %74
store float %72, float* %78
%80 = add nuw nsw i64 %11, 1
%81 = icmp eq i64 %80, %3
br i1 %81, label %82, label %10
82: ; preds = %10, %2
%83 = phi i64 [ 0, %2 ], [ %8, %10 ]
%84 = phi i32 [ 0, %2 ], [ %7, %10 ]
%85 = trunc i64 %83 to i32
%86 = add i32 %85, 8
%87 = add i32 %86, %84
%88 = add i32 %87, 8
%89 = zext i32 %87 to i64
%90 = getelementptr inbounds float, float* %0, i64 %89
%91 = load float, float* %90
%92 = add i32 %87, 1
%93 = zext i32 %92 to i64
%94 = getelementptr inbounds float, float* %0, i64 %93
%95 = load float, float* %94
%96 = zext i32 %88 to i64
%97 = getelementptr inbounds float, float* %0, i64 %96
%98 = load float, float* %97
%99 = add i32 %87, 9
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds float, float* %0, i64 %100
%102 = load float, float* %101
store float %98, float* %90
store float %102, float* %94
store float %91, float* %97
store float %95, float* %101
%103 = add nuw nsw i64 %3, 1
%104 = icmp eq i64 %103, 4
br i1 %104, label %105, label %2
105: ; preds = %82
ret void
}