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


x86 assembly (clang, -O0):
<bitrv2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xfd0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1040(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x3,%eax
cmp    -0x2c(%rbp),%eax
jge    1191 <bitrv2+0x91>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1183 <bitrv2+0x83>
movslq -0x1c(%rbp),%rax
mov    -0x1040(%rbp,%rax,4),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%eax
add    -0x1c(%rbp),%eax
cltq
mov    %ecx,-0x1040(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    114c <bitrv2+0x4c>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    112d <bitrv2+0x2d>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x3,%eax
cmp    -0x2c(%rbp),%eax
jne    1622 <bitrv2+0x522>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    161d <bitrv2+0x51d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1533 <bitrv2+0x433>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
movslq -0x24(%rbp),%rcx
add    -0x1040(%rbp,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
movslq -0x1c(%rbp),%rcx
add    -0x1040(%rbp,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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    11c3 <bitrv2+0xc3>
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
add    -0x34(%rbp),%eax
movslq -0x24(%rbp),%rcx
add    -0x1040(%rbp,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b0 <bitrv2+0xb0>
jmp    1820 <bitrv2+0x720>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    181b <bitrv2+0x71b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1808 <bitrv2+0x708>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
movslq -0x24(%rbp),%rcx
add    -0x1040(%rbp,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
movslq -0x1c(%rbp),%rcx
add    -0x1040(%rbp,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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,-0x1044(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1048(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1050(%rbp)
ff
movss  -0x104c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1050(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1044(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1048(%rbp),%xmm0
ff
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    163c <bitrv2+0x53c>
jmp    180d <bitrv2+0x70d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1629 <bitrv2+0x529>
jmp    1820 <bitrv2+0x720>
add    $0xfd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xfa8,%rsp
movl   $0x0,-0x60(%rsp)
cmp    $0x9,%edi
jl     1251 <bitrv2+0x151>
mov    $0x1,%r12d
lea    -0x30(%rsp),%r8
jmp    1142 <bitrv2+0x42>
nop
lea    (%r15,%r15,1),%r12d
mov    %r15d,%eax
shl    $0x4,%eax
cmp    %edi,%eax
jge    1268 <bitrv2+0x168>
mov    %r12d,%r15d
sar    %edi
test   %r12d,%r12d
jle    1130 <bitrv2+0x30>
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1160 <bitrv2+0x60>
xor    %eax,%eax
jmp    121b <bitrv2+0x11b>
nopl   0x0(%rax)
mov    %ecx,%eax
and    $0xfffffff8,%eax
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1247 <bitrv2+0x147>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r8,%rcx,4),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa -0x60(%rsp,%rbx,4),%xmm1
paddd  %xmm0,%xmm1
movdqa -0x50(%rsp,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rsi,%rbx,4)
movdqu %xmm2,-0x20(%rsi,%rbx,4)
movdqa -0x40(%rsp,%rbx,4),%xmm1
paddd  %xmm0,%xmm1
movdqa -0x30(%rsp,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x10(%rsi,%rbx,4)
movdqu %xmm2,(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    11a0 <bitrv2+0xa0>
test   $0x1,%r9b
je     1212 <bitrv2+0x112>
movdqa %xmm0,%xmm1
paddd  -0x60(%rsp,%rbx,4),%xmm1
movdqa -0x50(%rsp,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
add    %rcx,%rbx
movdqu %xmm1,-0x60(%rsp,%rbx,4)
movdqu %xmm2,-0x50(%rsp,%rbx,4)
cmp    %rcx,%rax
je     1130 <bitrv2+0x30>
lea    (%rsp,%rcx,4),%rsi
add    $0xffffffffffffffa0,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x60(%rsp,%rax,4),%ebp
add    %edi,%ebp
mov    %ebp,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1230 <bitrv2+0x130>
jmp    1130 <bitrv2+0x30>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    11ef <bitrv2+0xef>
jmp    1212 <bitrv2+0x112>
cmp    $0x8,%edi
jne    1468 <bitrv2+0x368>
mov    $0x2,%r15d
mov    $0x1,%r12d
jmp    127d <bitrv2+0x17d>
shl    $0x2,%r15d
cmp    %edi,%eax
jne    13bd <bitrv2+0x2bd>
test   %r12d,%r12d
jle    1468 <bitrv2+0x368>
movslq %r15d,%r11
mov    %r12d,%eax
mov    %rax,-0x70(%rsp)
shl    $0x2,%r12d
mov    -0x60(%rsp),%eax
mov    %eax,-0x7c(%rsp)
lea    0x0(,%r11,4),%r13
xor    %r14d,%r14d
mov    %r15,-0x78(%rsp)
jmp    12ef <bitrv2+0x1ef>
cs nopw 0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rdi
lea    (%r14,%rdi,1),%eax
lea    (%rcx,%rax,2),%eax
movslq %eax,%rcx
add    %r15d,%eax
mov    (%rdx,%rcx,4),%rsi
cltq
movd   (%rdx,%rax,4),%xmm0
movd   0x4(%rdx,%rax,4),%xmm1
movd   %xmm0,(%rdx,%rcx,4)
movd   %xmm1,0x4(%rdx,%rcx,4)
mov    %rsi,(%rdx,%rax,4)
add    $0x1,%r14
cmp    %rdi,%r14
je     1468 <bitrv2+0x368>
mov    -0x7c(%rsp),%eax
mov    %eax,%ecx
test   %r14,%r14
je     12b0 <bitrv2+0x1b0>
movslq -0x60(%rsp,%r14,4),%rax
lea    (%r14,%r14,1),%r15d
mov    %rax,-0x68(%rsp)
lea    (%rdx,%rax,4),%r10
xor    %ebx,%ebx
xchg   %ax,%ax
movslq -0x60(%rsp,%rbx,4),%rbp
movslq %r15d,%rcx
add    %rbp,%rcx
lea    (%r10,%rbx,8),%rbp
movd   (%r10,%rbx,8),%xmm0
movd   0x4(%r10,%rbx,8),%xmm1
movd   (%rdx,%rcx,4),%xmm2
movslq %ecx,%rdi
movss  0x4(%rdx,%rdi,4),%xmm3
movd   %xmm2,(%r10,%rbx,8)
movss  %xmm3,0x4(%r10,%rbx,8)
movd   %xmm0,(%rdx,%rcx,4)
movd   %xmm1,0x4(%rdx,%rdi,4)
add    %r12d,%edi
mov    %rbp,%rcx
add    %r13,%rcx
mov    0x0(%rbp,%r11,4),%r8
movslq %edi,%rdi
mov    (%rdx,%rdi,4),%r9
mov    %r9,0x0(%rbp,%r11,4)
mov    %r8,(%rdx,%rdi,4)
sub    %r11d,%edi
add    %r13,%rcx
mov    0x0(%rbp,%r11,8),%rsi
movslq %edi,%rdi
mov    (%rdx,%rdi,4),%rax
mov    %rax,0x0(%rbp,%r11,8)
mov    %rsi,(%rdx,%rdi,4)
add    %r12d,%edi
mov    (%rcx,%r11,4),%rax
movslq %edi,%rsi
mov    (%rdx,%rsi,4),%rdi
mov    %rdi,(%rcx,%r11,4)
mov    %rax,(%rdx,%rsi,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1310 <bitrv2+0x210>
mov    -0x78(%rsp),%r15
mov    -0x68(%rsp),%rcx
jmp    12b0 <bitrv2+0x1b0>
cmp    $0x2,%r12d
jl     1468 <bitrv2+0x368>
movslq %r15d,%r8
mov    %r12d,%r9d
lea    0x4(%rdx),%r10
mov    $0x1,%r11d
nopw   0x0(%rax,%rax,1)
movslq -0x60(%rsp,%r11,4),%rax
lea    (%r11,%r11,1),%r14d
lea    (%r8,%rax,1),%rcx
lea    (%r10,%rcx,4),%rbx
lea    (%r10,%rax,4),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movslq -0x60(%rsp,%rcx,4),%rsi
movslq %r14d,%rdi
add    %rsi,%rdi
movd   -0x4(%rax,%rcx,8),%xmm0
movd   (%rax,%rcx,8),%xmm1
movd   (%rdx,%rdi,4),%xmm2
movslq %edi,%rsi
movss  0x4(%rdx,%rsi,4),%xmm3
movd   %xmm2,-0x4(%rax,%rcx,8)
movss  %xmm3,(%rax,%rcx,8)
movd   %xmm0,(%rdx,%rdi,4)
movd   %xmm1,0x4(%rdx,%rsi,4)
add    %r15d,%esi
mov    -0x4(%rbx,%rcx,8),%rdi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%rbp
mov    %rbp,-0x4(%rbx,%rcx,8)
mov    %rdi,(%rdx,%rsi,4)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1400 <bitrv2+0x300>
add    $0x1,%r11
cmp    %r9,%r11
jne    13e0 <bitrv2+0x2e0>
add    $0xfa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
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 [1024 x i32]
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
store i32 %0, i32* %4
store i32* %1, i32** %5
store float* %2, float** %6
%19 = load i32*, i32** %5
%20 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 0
store i32 0, i32* %20
%21 = load i32, i32* %4
store i32 %21, i32* %11
store i32 1, i32* %12
br label %22
22: ; preds = %49, %3
%23 = load i32, i32* %12
%24 = shl i32 %23, 3
%25 = load i32, i32* %11
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %52
27: ; preds = %22
%28 = load i32, i32* %11
%29 = ashr i32 %28, 1
store i32 %29, i32* %11
store i32 0, i32* %7
br label %30
30: ; preds = %46, %27
%31 = load i32, i32* %7
%32 = load i32, i32* %12
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %49
34: ; preds = %30
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %36
%38 = load i32, i32* %37
%39 = load i32, i32* %11
%40 = add nsw i32 %38, %39
%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 [1024 x i32], [1024 x i32]* %14, i64 0, i64 %44
store i32 %40, i32* %45
br label %46
46: ; preds = %34
%47 = load i32, i32* %7
%48 = add nsw i32 %47, 1
store i32 %48, i32* %7
br label %30
49: ; preds = %30
%50 = load i32, i32* %12
%51 = shl i32 %50, 1
store i32 %51, i32* %12
br label %22
52: ; preds = %22
%53 = load i32, i32* %12
%54 = mul nsw i32 2, %53
store i32 %54, i32* %13
%55 = load i32, i32* %12
%56 = shl i32 %55, 3
%57 = load i32, i32* %11
%58 = icmp eq i32 %56, %57
br i1 %58, label %59, label %344
59: ; preds = %52
store i32 0, i32* %9
br label %60
60: ; preds = %340, %59
%61 = load i32, i32* %9
%62 = load i32, i32* %12
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %343
64: ; preds = %60
store i32 0, i32* %7
br label %65
65: ; preds = %280, %64
%66 = load i32, i32* %7
%67 = load i32, i32* %9
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %283
69: ; preds = %65
%70 = load i32, i32* %7
%71 = mul nsw i32 2, %70
%72 = load i32, i32* %9
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %73
%75 = load i32, i32* %74
%76 = add nsw i32 %71, %75
store i32 %76, i32* %8
%77 = load i32, i32* %9
%78 = mul nsw i32 2, %77
%79 = load i32, i32* %7
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %80
%82 = load i32, i32* %81
%83 = add nsw i32 %78, %82
store i32 %83, i32* %10
%84 = load float*, float** %6
%85 = load i32, i32* %8
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
store float %88, float* %15
%89 = load float*, float** %6
%90 = load i32, i32* %8
%91 = add nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %89, i64 %92
%94 = load float, float* %93
store float %94, float* %16
%95 = load float*, float** %6
%96 = load i32, i32* %10
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
store float %99, float* %17
%100 = load float*, float** %6
%101 = load i32, i32* %10
%102 = add nsw i32 %101, 1
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %100, i64 %103
%105 = load float, float* %104
store float %105, float* %18
%106 = load float, float* %17
%107 = load float*, float** %6
%108 = load i32, i32* %8
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
store float %106, float* %110
%111 = load float, float* %18
%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* %15
%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* %16
%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
%128 = load i32, i32* %13
%129 = load i32, i32* %8
%130 = add nsw i32 %129, %128
store i32 %130, i32* %8
%131 = load i32, i32* %13
%132 = mul nsw i32 2, %131
%133 = load i32, i32* %10
%134 = add nsw i32 %133, %132
store i32 %134, i32* %10
%135 = load float*, float** %6
%136 = load i32, i32* %8
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
store float %139, float* %15
%140 = load float*, float** %6
%141 = load i32, i32* %8
%142 = add nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %140, i64 %143
%145 = load float, float* %144
store float %145, float* %16
%146 = load float*, float** %6
%147 = load i32, i32* %10
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %146, i64 %148
%150 = load float, float* %149
store float %150, float* %17
%151 = load float*, float** %6
%152 = load i32, i32* %10
%153 = add nsw i32 %152, 1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %151, i64 %154
%156 = load float, float* %155
store float %156, float* %18
%157 = load float, float* %17
%158 = load float*, float** %6
%159 = load i32, i32* %8
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
store float %157, float* %161
%162 = load float, float* %18
%163 = load float*, float** %6
%164 = load i32, i32* %8
%165 = add nsw i32 %164, 1
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %163, i64 %166
store float %162, float* %167
%168 = load float, float* %15
%169 = load float*, float** %6
%170 = load i32, i32* %10
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
store float %168, float* %172
%173 = load float, float* %16
%174 = load float*, float** %6
%175 = load i32, i32* %10
%176 = add nsw i32 %175, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %174, i64 %177
store float %173, float* %178
%179 = load i32, i32* %13
%180 = load i32, i32* %8
%181 = add nsw i32 %180, %179
store i32 %181, i32* %8
%182 = load i32, i32* %13
%183 = load i32, i32* %10
%184 = sub nsw i32 %183, %182
store i32 %184, i32* %10
%185 = load float*, float** %6
%186 = load i32, i32* %8
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %185, i64 %187
%189 = load float, float* %188
store float %189, float* %15
%190 = load float*, float** %6
%191 = load i32, i32* %8
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %190, i64 %193
%195 = load float, float* %194
store float %195, float* %16
%196 = load float*, float** %6
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
store float %200, float* %17
%201 = load float*, float** %6
%202 = load i32, i32* %10
%203 = add nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds float, float* %201, i64 %204
%206 = load float, float* %205
store float %206, float* %18
%207 = load float, float* %17
%208 = load float*, float** %6
%209 = load i32, i32* %8
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %208, i64 %210
store float %207, float* %211
%212 = load float, float* %18
%213 = load float*, float** %6
%214 = load i32, i32* %8
%215 = add nsw i32 %214, 1
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %213, i64 %216
store float %212, float* %217
%218 = load float, float* %15
%219 = load float*, float** %6
%220 = load i32, i32* %10
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %219, i64 %221
store float %218, float* %222
%223 = load float, float* %16
%224 = load float*, float** %6
%225 = load i32, i32* %10
%226 = add nsw i32 %225, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %224, i64 %227
store float %223, float* %228
%229 = load i32, i32* %13
%230 = load i32, i32* %8
%231 = add nsw i32 %230, %229
store i32 %231, i32* %8
%232 = load i32, i32* %13
%233 = mul nsw i32 2, %232
%234 = load i32, i32* %10
%235 = add nsw i32 %234, %233
store i32 %235, i32* %10
%236 = load float*, float** %6
%237 = load i32, i32* %8
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds float, float* %236, i64 %238
%240 = load float, float* %239
store float %240, float* %15
%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
%246 = load float, float* %245
store float %246, float* %16
%247 = load float*, float** %6
%248 = load i32, i32* %10
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %247, i64 %249
%251 = load float, float* %250
store float %251, float* %17
%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
%257 = load float, float* %256
store float %257, float* %18
%258 = load float, float* %17
%259 = load float*, float** %6
%260 = load i32, i32* %8
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
store float %258, float* %262
%263 = load float, float* %18
%264 = load float*, float** %6
%265 = load i32, i32* %8
%266 = add nsw i32 %265, 1
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %264, i64 %267
store float %263, float* %268
%269 = load float, float* %15
%270 = load float*, float** %6
%271 = load i32, i32* %10
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %270, i64 %272
store float %269, float* %273
%274 = load float, float* %16
%275 = load float*, float** %6
%276 = load i32, i32* %10
%277 = add nsw i32 %276, 1
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds float, float* %275, i64 %278
store float %274, float* %279
br label %280
280: ; preds = %69
%281 = load i32, i32* %7
%282 = add nsw i32 %281, 1
store i32 %282, i32* %7
br label %65
283: ; preds = %65
%284 = load i32, i32* %9
%285 = mul nsw i32 2, %284
%286 = load i32, i32* %13
%287 = add nsw i32 %285, %286
%288 = load i32, i32* %9
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %289
%291 = load i32, i32* %290
%292 = add nsw i32 %287, %291
store i32 %292, i32* %8
%293 = load i32, i32* %8
%294 = load i32, i32* %13
%295 = add nsw i32 %293, %294
store i32 %295, i32* %10
%296 = load float*, float** %6
%297 = load i32, i32* %8
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds float, float* %296, i64 %298
%300 = load float, float* %299
store float %300, float* %15
%301 = load float*, float** %6
%302 = load i32, i32* %8
%303 = add nsw i32 %302, 1
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %301, i64 %304
%306 = load float, float* %305
store float %306, float* %16
%307 = load float*, float** %6
%308 = load i32, i32* %10
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %307, i64 %309
%311 = load float, float* %310
store float %311, float* %17
%312 = load float*, float** %6
%313 = load i32, i32* %10
%314 = add nsw i32 %313, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %312, i64 %315
%317 = load float, float* %316
store float %317, float* %18
%318 = load float, float* %17
%319 = load float*, float** %6
%320 = load i32, i32* %8
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds float, float* %319, i64 %321
store float %318, float* %322
%323 = load float, float* %18
%324 = load float*, float** %6
%325 = load i32, i32* %8
%326 = add nsw i32 %325, 1
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %324, i64 %327
store float %323, float* %328
%329 = load float, float* %15
%330 = load float*, float** %6
%331 = load i32, i32* %10
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %330, i64 %332
store float %329, float* %333
%334 = load float, float* %16
%335 = load float*, float** %6
%336 = load i32, i32* %10
%337 = add nsw i32 %336, 1
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds float, float* %335, i64 %338
store float %334, float* %339
br label %340
340: ; preds = %283
%341 = load i32, i32* %9
%342 = add nsw i32 %341, 1
store i32 %342, i32* %9
br label %60
343: ; preds = %60
br label %471
344: ; preds = %52
store i32 1, i32* %9
br label %345
345: ; preds = %467, %344
%346 = load i32, i32* %9
%347 = load i32, i32* %12
%348 = icmp slt i32 %346, %347
br i1 %348, label %349, label %470
349: ; preds = %345
store i32 0, i32* %7
br label %350
350: ; preds = %463, %349
%351 = load i32, i32* %7
%352 = load i32, i32* %9
%353 = icmp slt i32 %351, %352
br i1 %353, label %354, label %466
354: ; preds = %350
%355 = load i32, i32* %7
%356 = mul nsw i32 2, %355
%357 = load i32, i32* %9
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %358
%360 = load i32, i32* %359
%361 = add nsw i32 %356, %360
store i32 %361, i32* %8
%362 = load i32, i32* %9
%363 = mul nsw i32 2, %362
%364 = load i32, i32* %7
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [1024 x i32], [1024 x i32]* %14, i64 0, i64 %365
%367 = load i32, i32* %366
%368 = add nsw i32 %363, %367
store i32 %368, i32* %10
%369 = load float*, float** %6
%370 = load i32, i32* %8
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds float, float* %369, i64 %371
%373 = load float, float* %372
store float %373, float* %15
%374 = load float*, float** %6
%375 = load i32, i32* %8
%376 = add nsw i32 %375, 1
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %374, i64 %377
%379 = load float, float* %378
store float %379, float* %16
%380 = load float*, float** %6
%381 = load i32, i32* %10
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float, float* %380, i64 %382
%384 = load float, float* %383
store float %384, float* %17
%385 = load float*, float** %6
%386 = load i32, i32* %10
%387 = add nsw i32 %386, 1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %385, i64 %388
%390 = load float, float* %389
store float %390, float* %18
%391 = load float, float* %17
%392 = load float*, float** %6
%393 = load i32, i32* %8
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds float, float* %392, i64 %394
store float %391, float* %395
%396 = load float, float* %18
%397 = load float*, float** %6
%398 = load i32, i32* %8
%399 = add nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %397, i64 %400
store float %396, float* %401
%402 = load float, float* %15
%403 = load float*, float** %6
%404 = load i32, i32* %10
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %403, i64 %405
store float %402, float* %406
%407 = load float, float* %16
%408 = load float*, float** %6
%409 = load i32, i32* %10
%410 = add nsw i32 %409, 1
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds float, float* %408, i64 %411
store float %407, float* %412
%413 = load i32, i32* %13
%414 = load i32, i32* %8
%415 = add nsw i32 %414, %413
store i32 %415, i32* %8
%416 = load i32, i32* %13
%417 = load i32, i32* %10
%418 = add nsw i32 %417, %416
store i32 %418, i32* %10
%419 = load float*, float** %6
%420 = load i32, i32* %8
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds float, float* %419, i64 %421
%423 = load float, float* %422
store float %423, float* %15
%424 = load float*, float** %6
%425 = load i32, i32* %8
%426 = add nsw i32 %425, 1
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float, float* %424, i64 %427
%429 = load float, float* %428
store float %429, float* %16
%430 = load float*, float** %6
%431 = load i32, i32* %10
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float, float* %430, i64 %432
%434 = load float, float* %433
store float %434, float* %17
%435 = load float*, float** %6
%436 = load i32, i32* %10
%437 = add nsw i32 %436, 1
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds float, float* %435, i64 %438
%440 = load float, float* %439
store float %440, float* %18
%441 = load float, float* %17
%442 = load float*, float** %6
%443 = load i32, i32* %8
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float, float* %442, i64 %444
store float %441, float* %445
%446 = load float, float* %18
%447 = load float*, float** %6
%448 = load i32, i32* %8
%449 = add nsw i32 %448, 1
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %447, i64 %450
store float %446, float* %451
%452 = load float, float* %15
%453 = load float*, float** %6
%454 = load i32, i32* %10
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds float, float* %453, i64 %455
store float %452, float* %456
%457 = load float, float* %16
%458 = load float*, float** %6
%459 = load i32, i32* %10
%460 = add nsw i32 %459, 1
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float, float* %458, i64 %461
store float %457, float* %462
br label %463
463: ; preds = %354
%464 = load i32, i32* %7
%465 = add nsw i32 %464, 1
store i32 %465, i32* %7
br label %350
466: ; preds = %350
br label %467
467: ; preds = %466
%468 = load i32, i32* %9
%469 = add nsw i32 %468, 1
store i32 %469, i32* %9
br label %345
470: ; preds = %345
br label %471
471: ; preds = %470, %343
ret void
}

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