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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void bitrv2(size_t n, size_t *ip, float *a) {
  size_t j, j1, k, k1, l, m, m2;
  float xr, xi, yr, yi;
  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
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
movq   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
cmp    -0x40(%rbp),%rax
jae    11a1 <bitrv2+0xa1>
mov    -0x40(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1190 <bitrv2+0x90>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1151 <bitrv2+0x51>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    112b <bitrv2+0x2b>
mov    -0x48(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
cmp    -0x40(%rbp),%rax
jne    15a1 <bitrv2+0x4a1>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    159c <bitrv2+0x49c>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    14cf <bitrv2+0x3cf>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11dd <bitrv2+0xdd>
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    -0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11c7 <bitrv2+0xc7>
jmp    1769 <bitrv2+0x669>
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1764 <bitrv2+0x664>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    174e <bitrv2+0x64e>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x20(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    15bf <bitrv2+0x4bf>
jmp    1753 <bitrv2+0x653>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    15a9 <bitrv2+0x4a9>
jmp    1769 <bitrv2+0x669>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movq   $0x0,(%rsi)
cmp    $0x9,%rdi
jb     1253 <bitrv2+0x153>
lea    0x30(%rsi),%r9
mov    $0x1,%r8d
jmp    1144 <bitrv2+0x44>
nopw   0x0(%rax,%rax,1)
lea    (%r11,%r11,1),%r8
mov    %r11,%rax
shl    $0x4,%rax
cmp    %rdi,%rax
jae    126b <bitrv2+0x16b>
mov    %r8,%r11
shr    %rdi
test   %r8,%r8
je     1130 <bitrv2+0x30>
cmp    $0x4,%r11
jae    1160 <bitrv2+0x60>
xor    %eax,%eax
jmp    1220 <bitrv2+0x120>
nopl   0x0(%rax)
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
movq   %rdi,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1249 <bitrv2+0x149>
mov    %r8,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r9,%r11,8),%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movdqu -0x30(%r9,%rcx,8),%xmm1
movdqu -0x20(%r9,%rcx,8),%xmm2
paddq  %xmm0,%xmm1
paddq  %xmm0,%xmm2
movdqu %xmm1,-0x30(%r10,%rcx,8)
movdqu %xmm2,-0x20(%r10,%rcx,8)
movdqu -0x10(%r9,%rcx,8),%xmm1
movdqu (%r9,%rcx,8),%xmm2
paddq  %xmm0,%xmm1
paddq  %xmm0,%xmm2
movdqu %xmm1,-0x10(%r10,%rcx,8)
movdqu %xmm2,(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbx
jne    11a0 <bitrv2+0xa0>
test   $0x1,%r8b
je     1217 <bitrv2+0x117>
movdqu (%rsi,%rcx,8),%xmm1
movdqu 0x10(%rsi,%rcx,8),%xmm2
paddq  %xmm0,%xmm1
paddq  %xmm0,%xmm2
add    %r11,%rcx
movdqu %xmm1,(%rsi,%rcx,8)
movdqu %xmm2,0x10(%rsi,%rcx,8)
cmp    %rax,%r11
je     1130 <bitrv2+0x30>
lea    (%rsi,%r11,8),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rax,8),%rbx
add    %rdi,%rbx
mov    %rbx,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1230 <bitrv2+0x130>
jmp    1130 <bitrv2+0x30>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    11f6 <bitrv2+0xf6>
jmp    1217 <bitrv2+0x117>
cmp    $0x8,%rdi
jne    13f0 <bitrv2+0x2f0>
mov    $0x2,%r11d
mov    $0x1,%r8d
jmp    1281 <bitrv2+0x181>
shl    $0x2,%r11
cmp    %rdi,%rax
jne    1377 <bitrv2+0x277>
test   %r8,%r8
je     13f0 <bitrv2+0x2f0>
lea    0x0(,%r8,4),%r15
lea    0x0(,%r11,4),%r12
xor    %r9d,%r9d
jmp    12da <bitrv2+0x1da>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi),%rcx
lea    (%r9,%r8,1),%rax
lea    (%rcx,%rax,2),%rax
lea    (%rax,%r11,1),%rcx
mov    (%rdx,%rax,4),%rdi
movd   (%rdx,%rcx,4),%xmm0
movd   0x4(%rdx,%rcx,4),%xmm1
movd   %xmm0,(%rdx,%rax,4)
movd   %xmm1,0x4(%rdx,%rax,4)
mov    %rdi,(%rdx,%rcx,4)
add    $0x1,%r9
cmp    %r8,%r9
je     13f0 <bitrv2+0x2f0>
test   %r9,%r9
je     12a0 <bitrv2+0x1a0>
mov    (%rsi,%r9,8),%rax
lea    (%r9,%r9,1),%r14
mov    %rax,-0x8(%rsp)
lea    (%rdx,%rax,4),%r13
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rcx,8),%rax
add    %r14,%rax
lea    0x0(,%rcx,8),%rdi
add    %r13,%rdi
mov    0x0(%r13,%rcx,8),%rbx
mov    (%rdx,%rax,4),%rbp
mov    %rbp,0x0(%r13,%rcx,8)
mov    %rbx,(%rdx,%rax,4)
add    %r15,%rax
lea    (%rdi,%r12,1),%rbx
mov    (%rdi,%r11,4),%rbp
mov    (%rdx,%rax,4),%r10
mov    %r10,(%rdi,%r11,4)
mov    %rbp,(%rdx,%rax,4)
sub    %r11,%rax
add    %r12,%rbx
mov    (%rdi,%r11,8),%r10
mov    (%rdx,%rax,4),%rbp
mov    %rbp,(%rdi,%r11,8)
mov    %r10,(%rdx,%rax,4)
add    %r15,%rax
mov    (%rbx,%r11,4),%rdi
mov    (%rdx,%rax,4),%rbp
mov    %rbp,(%rbx,%r11,4)
mov    %rdi,(%rdx,%rax,4)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1300 <bitrv2+0x200>
mov    -0x8(%rsp),%rcx
jmp    12a3 <bitrv2+0x1a3>
test   %r8,%r8
je     13f0 <bitrv2+0x2f0>
lea    0x4(%rdx),%r9
lea    (%rdx,%r11,4),%r10
add    $0x4,%r10
mov    $0x1,%r14d
xchg   %ax,%ax
mov    (%rsi,%r14,8),%rcx
lea    (%r14,%r14,1),%r15
lea    (%r10,%rcx,4),%r12
lea    (%r9,%rcx,4),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rdi,8),%rbp
add    %r15,%rbp
mov    -0x4(%rcx,%rdi,8),%rbx
mov    (%rdx,%rbp,4),%rax
mov    %rax,-0x4(%rcx,%rdi,8)
mov    %rbx,(%rdx,%rbp,4)
add    %r11,%rbp
mov    -0x4(%r12,%rdi,8),%rax
mov    (%rdx,%rbp,4),%rbx
mov    %rbx,-0x4(%r12,%rdi,8)
mov    %rax,(%rdx,%rbp,4)
add    $0x1,%rdi
cmp    %rdi,%r14
jne    13b0 <bitrv2+0x2b0>
add    $0x1,%r14
cmp    %r8,%r14
jne    1390 <bitrv2+0x290>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @bitrv2(i64 %0, i64* %1, float* %2) {
%4 = alloca i64
%5 = alloca i64*
%6 = alloca float*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
store i64 %0, i64* %4
store i64* %1, i64** %5
store float* %2, float** %6
%18 = load i64*, i64** %5
%19 = getelementptr inbounds i64, i64* %18, i64 0
store i64 0, i64* %19
%20 = load i64, i64* %4
store i64 %20, i64* %11
store i64 1, i64* %12
br label %21
21: ; preds = %48, %3
%22 = load i64, i64* %12
%23 = shl i64 %22, 3
%24 = load i64, i64* %11
%25 = icmp ult i64 %23, %24
br i1 %25, label %26, label %51
26: ; preds = %21
%27 = load i64, i64* %11
%28 = lshr i64 %27, 1
store i64 %28, i64* %11
store i64 0, i64* %7
br label %29
29: ; preds = %45, %26
%30 = load i64, i64* %7
%31 = load i64, i64* %12
%32 = icmp ult i64 %30, %31
br i1 %32, label %33, label %48
33: ; preds = %29
%34 = load i64*, i64** %5
%35 = load i64, i64* %7
%36 = getelementptr inbounds i64, i64* %34, i64 %35
%37 = load i64, i64* %36
%38 = load i64, i64* %11
%39 = add i64 %37, %38
%40 = load i64*, i64** %5
%41 = load i64, i64* %12
%42 = load i64, i64* %7
%43 = add i64 %41, %42
%44 = getelementptr inbounds i64, i64* %40, i64 %43
store i64 %39, i64* %44
br label %45
45: ; preds = %33
%46 = load i64, i64* %7
%47 = add i64 %46, 1
store i64 %47, i64* %7
br label %29
48: ; preds = %29
%49 = load i64, i64* %12
%50 = shl i64 %49, 1
store i64 %50, i64* %12
br label %21
51: ; preds = %21
%52 = load i64, i64* %12
%53 = mul i64 2, %52
store i64 %53, i64* %13
%54 = load i64, i64* %12
%55 = shl i64 %54, 3
%56 = load i64, i64* %11
%57 = icmp eq i64 %55, %56
br i1 %57, label %58, label %303
58: ; preds = %51
store i64 0, i64* %9
br label %59
59: ; preds = %299, %58
%60 = load i64, i64* %9
%61 = load i64, i64* %12
%62 = icmp ult i64 %60, %61
br i1 %62, label %63, label %302
63: ; preds = %59
store i64 0, i64* %7
br label %64
64: ; preds = %247, %63
%65 = load i64, i64* %7
%66 = load i64, i64* %9
%67 = icmp ult i64 %65, %66
br i1 %67, label %68, label %250
68: ; preds = %64
%69 = load i64, i64* %7
%70 = mul i64 2, %69
%71 = load i64*, i64** %5
%72 = load i64, i64* %9
%73 = getelementptr inbounds i64, i64* %71, i64 %72
%74 = load i64, i64* %73
%75 = add i64 %70, %74
store i64 %75, i64* %8
%76 = load i64, i64* %9
%77 = mul i64 2, %76
%78 = load i64*, i64** %5
%79 = load i64, i64* %7
%80 = getelementptr inbounds i64, i64* %78, i64 %79
%81 = load i64, i64* %80
%82 = add i64 %77, %81
store i64 %82, i64* %10
%83 = load float*, float** %6
%84 = load i64, i64* %8
%85 = getelementptr inbounds float, float* %83, i64 %84
%86 = load float, float* %85
store float %86, float* %14
%87 = load float*, float** %6
%88 = load i64, i64* %8
%89 = add i64 %88, 1
%90 = getelementptr inbounds float, float* %87, i64 %89
%91 = load float, float* %90
store float %91, float* %15
%92 = load float*, float** %6
%93 = load i64, i64* %10
%94 = getelementptr inbounds float, float* %92, i64 %93
%95 = load float, float* %94
store float %95, float* %16
%96 = load float*, float** %6
%97 = load i64, i64* %10
%98 = add i64 %97, 1
%99 = getelementptr inbounds float, float* %96, i64 %98
%100 = load float, float* %99
store float %100, float* %17
%101 = load float, float* %16
%102 = load float*, float** %6
%103 = load i64, i64* %8
%104 = getelementptr inbounds float, float* %102, i64 %103
store float %101, float* %104
%105 = load float, float* %17
%106 = load float*, float** %6
%107 = load i64, i64* %8
%108 = add i64 %107, 1
%109 = getelementptr inbounds float, float* %106, i64 %108
store float %105, float* %109
%110 = load float, float* %14
%111 = load float*, float** %6
%112 = load i64, i64* %10
%113 = getelementptr inbounds float, float* %111, i64 %112
store float %110, float* %113
%114 = load float, float* %15
%115 = load float*, float** %6
%116 = load i64, i64* %10
%117 = add i64 %116, 1
%118 = getelementptr inbounds float, float* %115, i64 %117
store float %114, float* %118
%119 = load i64, i64* %13
%120 = load i64, i64* %8
%121 = add i64 %120, %119
store i64 %121, i64* %8
%122 = load i64, i64* %13
%123 = mul i64 2, %122
%124 = load i64, i64* %10
%125 = add i64 %124, %123
store i64 %125, i64* %10
%126 = load float*, float** %6
%127 = load i64, i64* %8
%128 = getelementptr inbounds float, float* %126, i64 %127
%129 = load float, float* %128
store float %129, float* %14
%130 = load float*, float** %6
%131 = load i64, i64* %8
%132 = add i64 %131, 1
%133 = getelementptr inbounds float, float* %130, i64 %132
%134 = load float, float* %133
store float %134, float* %15
%135 = load float*, float** %6
%136 = load i64, i64* %10
%137 = getelementptr inbounds float, float* %135, i64 %136
%138 = load float, float* %137
store float %138, float* %16
%139 = load float*, float** %6
%140 = load i64, i64* %10
%141 = add i64 %140, 1
%142 = getelementptr inbounds float, float* %139, i64 %141
%143 = load float, float* %142
store float %143, float* %17
%144 = load float, float* %16
%145 = load float*, float** %6
%146 = load i64, i64* %8
%147 = getelementptr inbounds float, float* %145, i64 %146
store float %144, float* %147
%148 = load float, float* %17
%149 = load float*, float** %6
%150 = load i64, i64* %8
%151 = add i64 %150, 1
%152 = getelementptr inbounds float, float* %149, i64 %151
store float %148, float* %152
%153 = load float, float* %14
%154 = load float*, float** %6
%155 = load i64, i64* %10
%156 = getelementptr inbounds float, float* %154, i64 %155
store float %153, float* %156
%157 = load float, float* %15
%158 = load float*, float** %6
%159 = load i64, i64* %10
%160 = add i64 %159, 1
%161 = getelementptr inbounds float, float* %158, i64 %160
store float %157, float* %161
%162 = load i64, i64* %13
%163 = load i64, i64* %8
%164 = add i64 %163, %162
store i64 %164, i64* %8
%165 = load i64, i64* %13
%166 = load i64, i64* %10
%167 = sub i64 %166, %165
store i64 %167, i64* %10
%168 = load float*, float** %6
%169 = load i64, i64* %8
%170 = getelementptr inbounds float, float* %168, i64 %169
%171 = load float, float* %170
store float %171, float* %14
%172 = load float*, float** %6
%173 = load i64, i64* %8
%174 = add i64 %173, 1
%175 = getelementptr inbounds float, float* %172, i64 %174
%176 = load float, float* %175
store float %176, float* %15
%177 = load float*, float** %6
%178 = load i64, i64* %10
%179 = getelementptr inbounds float, float* %177, i64 %178
%180 = load float, float* %179
store float %180, float* %16
%181 = load float*, float** %6
%182 = load i64, i64* %10
%183 = add i64 %182, 1
%184 = getelementptr inbounds float, float* %181, i64 %183
%185 = load float, float* %184
store float %185, float* %17
%186 = load float, float* %16
%187 = load float*, float** %6
%188 = load i64, i64* %8
%189 = getelementptr inbounds float, float* %187, i64 %188
store float %186, float* %189
%190 = load float, float* %17
%191 = load float*, float** %6
%192 = load i64, i64* %8
%193 = add i64 %192, 1
%194 = getelementptr inbounds float, float* %191, i64 %193
store float %190, float* %194
%195 = load float, float* %14
%196 = load float*, float** %6
%197 = load i64, i64* %10
%198 = getelementptr inbounds float, float* %196, i64 %197
store float %195, float* %198
%199 = load float, float* %15
%200 = load float*, float** %6
%201 = load i64, i64* %10
%202 = add i64 %201, 1
%203 = getelementptr inbounds float, float* %200, i64 %202
store float %199, float* %203
%204 = load i64, i64* %13
%205 = load i64, i64* %8
%206 = add i64 %205, %204
store i64 %206, i64* %8
%207 = load i64, i64* %13
%208 = mul i64 2, %207
%209 = load i64, i64* %10
%210 = add i64 %209, %208
store i64 %210, i64* %10
%211 = load float*, float** %6
%212 = load i64, i64* %8
%213 = getelementptr inbounds float, float* %211, i64 %212
%214 = load float, float* %213
store float %214, float* %14
%215 = load float*, float** %6
%216 = load i64, i64* %8
%217 = add i64 %216, 1
%218 = getelementptr inbounds float, float* %215, i64 %217
%219 = load float, float* %218
store float %219, float* %15
%220 = load float*, float** %6
%221 = load i64, i64* %10
%222 = getelementptr inbounds float, float* %220, i64 %221
%223 = load float, float* %222
store float %223, float* %16
%224 = load float*, float** %6
%225 = load i64, i64* %10
%226 = add i64 %225, 1
%227 = getelementptr inbounds float, float* %224, i64 %226
%228 = load float, float* %227
store float %228, float* %17
%229 = load float, float* %16
%230 = load float*, float** %6
%231 = load i64, i64* %8
%232 = getelementptr inbounds float, float* %230, i64 %231
store float %229, float* %232
%233 = load float, float* %17
%234 = load float*, float** %6
%235 = load i64, i64* %8
%236 = add i64 %235, 1
%237 = getelementptr inbounds float, float* %234, i64 %236
store float %233, float* %237
%238 = load float, float* %14
%239 = load float*, float** %6
%240 = load i64, i64* %10
%241 = getelementptr inbounds float, float* %239, i64 %240
store float %238, float* %241
%242 = load float, float* %15
%243 = load float*, float** %6
%244 = load i64, i64* %10
%245 = add i64 %244, 1
%246 = getelementptr inbounds float, float* %243, i64 %245
store float %242, float* %246
br label %247
247: ; preds = %68
%248 = load i64, i64* %7
%249 = add i64 %248, 1
store i64 %249, i64* %7
br label %64
250: ; preds = %64
%251 = load i64, i64* %9
%252 = mul i64 2, %251
%253 = load i64, i64* %13
%254 = add i64 %252, %253
%255 = load i64*, i64** %5
%256 = load i64, i64* %9
%257 = getelementptr inbounds i64, i64* %255, i64 %256
%258 = load i64, i64* %257
%259 = add i64 %254, %258
store i64 %259, i64* %8
%260 = load i64, i64* %8
%261 = load i64, i64* %13
%262 = add i64 %260, %261
store i64 %262, i64* %10
%263 = load float*, float** %6
%264 = load i64, i64* %8
%265 = getelementptr inbounds float, float* %263, i64 %264
%266 = load float, float* %265
store float %266, float* %14
%267 = load float*, float** %6
%268 = load i64, i64* %8
%269 = add i64 %268, 1
%270 = getelementptr inbounds float, float* %267, i64 %269
%271 = load float, float* %270
store float %271, float* %15
%272 = load float*, float** %6
%273 = load i64, i64* %10
%274 = getelementptr inbounds float, float* %272, i64 %273
%275 = load float, float* %274
store float %275, float* %16
%276 = load float*, float** %6
%277 = load i64, i64* %10
%278 = add i64 %277, 1
%279 = getelementptr inbounds float, float* %276, i64 %278
%280 = load float, float* %279
store float %280, float* %17
%281 = load float, float* %16
%282 = load float*, float** %6
%283 = load i64, i64* %8
%284 = getelementptr inbounds float, float* %282, i64 %283
store float %281, float* %284
%285 = load float, float* %17
%286 = load float*, float** %6
%287 = load i64, i64* %8
%288 = add i64 %287, 1
%289 = getelementptr inbounds float, float* %286, i64 %288
store float %285, float* %289
%290 = load float, float* %14
%291 = load float*, float** %6
%292 = load i64, i64* %10
%293 = getelementptr inbounds float, float* %291, i64 %292
store float %290, float* %293
%294 = load float, float* %15
%295 = load float*, float** %6
%296 = load i64, i64* %10
%297 = add i64 %296, 1
%298 = getelementptr inbounds float, float* %295, i64 %297
store float %294, float* %298
br label %299
299: ; preds = %250
%300 = load i64, i64* %9
%301 = add i64 %300, 1
store i64 %301, i64* %9
br label %59
302: ; preds = %59
br label %414
303: ; preds = %51
store i64 1, i64* %9
br label %304
304: ; preds = %410, %303
%305 = load i64, i64* %9
%306 = load i64, i64* %12
%307 = icmp ult i64 %305, %306
br i1 %307, label %308, label %413
308: ; preds = %304
store i64 0, i64* %7
br label %309
309: ; preds = %406, %308
%310 = load i64, i64* %7
%311 = load i64, i64* %9
%312 = icmp ult i64 %310, %311
br i1 %312, label %313, label %409
313: ; preds = %309
%314 = load i64, i64* %7
%315 = mul i64 2, %314
%316 = load i64*, i64** %5
%317 = load i64, i64* %9
%318 = getelementptr inbounds i64, i64* %316, i64 %317
%319 = load i64, i64* %318
%320 = add i64 %315, %319
store i64 %320, i64* %8
%321 = load i64, i64* %9
%322 = mul i64 2, %321
%323 = load i64*, i64** %5
%324 = load i64, i64* %7
%325 = getelementptr inbounds i64, i64* %323, i64 %324
%326 = load i64, i64* %325
%327 = add i64 %322, %326
store i64 %327, i64* %10
%328 = load float*, float** %6
%329 = load i64, i64* %8
%330 = getelementptr inbounds float, float* %328, i64 %329
%331 = load float, float* %330
store float %331, float* %14
%332 = load float*, float** %6
%333 = load i64, i64* %8
%334 = add i64 %333, 1
%335 = getelementptr inbounds float, float* %332, i64 %334
%336 = load float, float* %335
store float %336, float* %15
%337 = load float*, float** %6
%338 = load i64, i64* %10
%339 = getelementptr inbounds float, float* %337, i64 %338
%340 = load float, float* %339
store float %340, float* %16
%341 = load float*, float** %6
%342 = load i64, i64* %10
%343 = add i64 %342, 1
%344 = getelementptr inbounds float, float* %341, i64 %343
%345 = load float, float* %344
store float %345, float* %17
%346 = load float, float* %16
%347 = load float*, float** %6
%348 = load i64, i64* %8
%349 = getelementptr inbounds float, float* %347, i64 %348
store float %346, float* %349
%350 = load float, float* %17
%351 = load float*, float** %6
%352 = load i64, i64* %8
%353 = add i64 %352, 1
%354 = getelementptr inbounds float, float* %351, i64 %353
store float %350, float* %354
%355 = load float, float* %14
%356 = load float*, float** %6
%357 = load i64, i64* %10
%358 = getelementptr inbounds float, float* %356, i64 %357
store float %355, float* %358
%359 = load float, float* %15
%360 = load float*, float** %6
%361 = load i64, i64* %10
%362 = add i64 %361, 1
%363 = getelementptr inbounds float, float* %360, i64 %362
store float %359, float* %363
%364 = load i64, i64* %13
%365 = load i64, i64* %8
%366 = add i64 %365, %364
store i64 %366, i64* %8
%367 = load i64, i64* %13
%368 = load i64, i64* %10
%369 = add i64 %368, %367
store i64 %369, i64* %10
%370 = load float*, float** %6
%371 = load i64, i64* %8
%372 = getelementptr inbounds float, float* %370, i64 %371
%373 = load float, float* %372
store float %373, float* %14
%374 = load float*, float** %6
%375 = load i64, i64* %8
%376 = add i64 %375, 1
%377 = getelementptr inbounds float, float* %374, i64 %376
%378 = load float, float* %377
store float %378, float* %15
%379 = load float*, float** %6
%380 = load i64, i64* %10
%381 = getelementptr inbounds float, float* %379, i64 %380
%382 = load float, float* %381
store float %382, float* %16
%383 = load float*, float** %6
%384 = load i64, i64* %10
%385 = add i64 %384, 1
%386 = getelementptr inbounds float, float* %383, i64 %385
%387 = load float, float* %386
store float %387, float* %17
%388 = load float, float* %16
%389 = load float*, float** %6
%390 = load i64, i64* %8
%391 = getelementptr inbounds float, float* %389, i64 %390
store float %388, float* %391
%392 = load float, float* %17
%393 = load float*, float** %6
%394 = load i64, i64* %8
%395 = add i64 %394, 1
%396 = getelementptr inbounds float, float* %393, i64 %395
store float %392, float* %396
%397 = load float, float* %14
%398 = load float*, float** %6
%399 = load i64, i64* %10
%400 = getelementptr inbounds float, float* %398, i64 %399
store float %397, float* %400
%401 = load float, float* %15
%402 = load float*, float** %6
%403 = load i64, i64* %10
%404 = add i64 %403, 1
%405 = getelementptr inbounds float, float* %402, i64 %404
store float %401, float* %405
br label %406
406: ; preds = %313
%407 = load i64, i64* %7
%408 = add i64 %407, 1
store i64 %408, i64* %7
br label %309
409: ; preds = %309
br label %410
410: ; preds = %409
%411 = load i64, i64* %9
%412 = add i64 %411, 1
store i64 %412, i64* %9
br label %304
413: ; preds = %304
br label %414
414: ; preds = %413, %302
ret void
}

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