void bitrv2(int n, int *ip, float *a) {
  int j, j1, k, k1, l, m, nh, nm;
  float xr, xi, yr, yi;
  m = 1;
  for (l = n >> 2; l > 8; l >>= 2) {
    m <<= 1;
  }
  nh = n >> 1;
  nm = 4 * m;
  if (l == 8) {
    for (k = 0; k < m; k++) {
      for (j = 0; j < k; j++) {
        j1 = 4 * j + 2 * ip[m + k];
        k1 = 4 * k + 2 * ip[m + 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 += nm;
        k1 += 2 * nm;
        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 += nm;
        k1 -= nm;
        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 += nm;
        k1 += 2 * nm;
        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 += nh;
        k1 += 2;
        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 -= nm;
        k1 -= 2 * nm;
        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 -= nm;
        k1 += nm;
        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 -= nm;
        k1 -= 2 * nm;
        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;
        k1 += nh;
        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 += nm;
        k1 += 2 * nm;
        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 += nm;
        k1 -= nm;
        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 += nm;
        k1 += 2 * nm;
        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 -= nh;
        k1 -= 2;
        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 -= nm;
        k1 -= 2 * nm;
        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 -= nm;
        k1 += nm;
        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 -= nm;
        k1 -= 2 * nm;
        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;
      }
      k1 = 4 * k + 2 * ip[m + k];
      j1 = k1 + 2;
      k1 += nh;
      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 += nm;
      k1 += 2 * nm;
      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 += nm;
      k1 -= nm;
      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;
      k1 -= nh;
      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 += nh + 2;
      k1 += nh + 2;
      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 -= nh - nm;
      k1 += 2 * nm - 2;
      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 = 0; k < m; k++) {
      for (j = 0; j < k; j++) {
        j1 = 4 * j + ip[m + k];
        k1 = 4 * k + ip[m + 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 += nm;
        k1 += nm;
        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 += nh;
        k1 += 2;
        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 -= nm;
        k1 -= nm;
        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;
        k1 += nh;
        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 += nm;
        k1 += nm;
        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 -= nh;
        k1 -= 2;
        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 -= nm;
        k1 -= nm;
        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;
      }
      k1 = 4 * k + ip[m + k];
      j1 = k1 + 2;
      k1 += nh;
      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 += nm;
      k1 += nm;
      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    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jle    1140 <bitrv2+0x40>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    111f <bitrv2+0x1f>
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jne    21d9 <bitrv2+0x10d9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    21d4 <bitrv2+0x10d4>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1d4c <bitrv2+0xc4c>
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x2,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1176 <bitrv2+0x76>
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
sub    $0x2,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
sub    $0x2,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
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    1163 <bitrv2+0x63>
jmp    297f <bitrv2+0x187f>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    297a <bitrv2+0x187a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    27e7 <bitrv2+0x16e7>
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x2,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    21f3 <bitrv2+0x10f3>
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%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,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
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    21e0 <bitrv2+0x10e0>
jmp    297f <bitrv2+0x187f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb0,%rsp
mov    %rsi,%r8
mov    $0x1,%eax
mov    %edi,%esi
nopl   0x0(%rax,%rax,1)
mov    %eax,%r15d
mov    %esi,%ebp
sar    $0x2,%esi
lea    (%r15,%r15,1),%eax
cmp    $0x23,%ebp
jg     1120 <bitrv2+0x20>
sar    %edi
lea    0x0(,%r15,4),%ecx
cmp    $0x8,%esi
mov    %r8,-0x10(%rsp)
jne    1897 <bitrv2+0x797>
test   %r15d,%r15d
jle    1bc0 <bitrv2+0xac0>
movabs $0x400000000,%r13
movslq %ecx,%rsi
movslq %edi,%rbx
mov    %r15d,%r11d
shl    $0x3,%r15d
lea    (%rdx,%rsi,4),%rax
add    $0x4,%rax
mov    %rax,0x58(%rsp)
mov    %rsi,%r9
lea    (%rsi,%rsi,2),%rbp
lea    (%rbx,%rbp,1),%rax
mov    %rax,0x50(%rsp)
lea    (%rbx,%rsi,2),%rax
mov    %rax,0x48(%rsp)
lea    (%rdx,%rbx,4),%rax
add    %rsi,%rbx
mov    %rbx,0x68(%rsp)
lea    (%rax,%rsi,8),%rbx
mov    %rbx,0x38(%rsp)
lea    (%rdx,%rsi,8),%rbx
mov    %rbx,0x30(%rsp)
shl    $0x21,%rsi
mov    %rsi,0x28(%rsp)
shl    $0x20,%r9
lea    (%r9,%r9,2),%rsi
mov    %rsi,0x20(%rsp)
mov    %rax,0x40(%rsp)
lea    (%rax,%rbp,4),%rax
mov    %rax,0x18(%rsp)
lea    (%rdx,%rbp,4),%rax
mov    %rax,0x10(%rsp)
lea    (%r8,%r11,4),%rax
mov    %rax,0x80(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,0x8(%rsp)
lea    (%rcx,%rcx,2),%eax
mov    %rax,(%rsp)
add    %edi,%eax
add    $0x2,%eax
mov    %rax,-0x8(%rsp)
xor    %r12d,%r12d
xor    %r14d,%r14d
mov    %r11,0x60(%rsp)
jmp    1377 <bitrv2+0x277>
movslq (%r8,%rax,4),%rax
movslq %r10d,%rsi
lea    (%rsi,%rax,2),%rbx
lea    (%rsi,%rax,2),%rax
add    $0x2,%rax
movss  0x8(%rdx,%rbx,4),%xmm0
movslq %ebx,%rsi
lea    (%rbx,%rdi,1),%ebp
movss  0xc(%rdx,%rsi,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,0x8(%rdx,%rbx,4)
movss  %xmm3,0xc(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,0x4(%rdx,%rbp,4)
add    %ecx,%eax
add    %r15d,%ebp
cltq
movss  (%rdx,%rax,4),%xmm0
mov    %eax,%esi
or     $0x1,%esi
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,0x4(%rdx,%rbp,4)
add    %ecx,%eax
sub    %ecx,%ebp
movslq %eax,%r9
movss  (%rdx,%r9,4),%xmm0
mov    %r9d,%eax
or     $0x1,%eax
cltq
movss  (%rdx,%rax,4),%xmm1
movslq %ebp,%rsi
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%r9,4)
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm0,(%rdx,%rsi,4)
movss  %xmm1,0x4(%rdx,%rsi,4)
mov    %esi,%eax
sub    %edi,%eax
mov    -0x8(%rdx,%r9,4),%rbp
cltq
mov    (%rdx,%rax,4),%rbx
mov    %rbx,-0x8(%rdx,%r9,4)
mov    %rbp,(%rdx,%rax,4)
lea    (%r9,%rdi,1),%eax
lea    0x2(%rsi),%ebp
cltq
movss  (%rdx,%rax,4),%xmm0
movss  0x4(%rdx,%rax,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
lea    0x3(%rsi),%ebx
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,0x4(%rdx,%rax,4)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,(%rdx,%rbx,4)
lea    (%r9,%rcx,1),%eax
add    %r15d,%esi
cltq
movss  (%rdx,%rax,4),%xmm0
mov    %eax,%ebp
or     $0x1,%ebp
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm1
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rbp,4)
movss  %xmm0,(%rdx,%rsi,4)
movss  %xmm1,0x4(%rdx,%rsi,4)
add    $0x1,%r14
add    $0x4,%r12
cmp    %r11,%r14
je     1bc0 <bitrv2+0xac0>
lea    (%r14,%r11,1),%rax
mov    $0x0,%r10d
test   %r14,%r14
je     1210 <bitrv2+0x110>
mov    %rax,0x70(%rsp)
movslq (%r8,%rax,4),%rsi
lea    (%rsi,%rsi,1),%rbp
mov    %r14,0x78(%rsp)
movslq %r14d,%r10
shl    $0x2,%r10
lea    (%rdx,%rsi,8),%r11
mov    0x58(%rsp),%rax
lea    (%rax,%rsi,8),%r9
mov    0x68(%rsp),%rax
lea    (%rax,%rsi,2),%r8
mov    0x40(%rsp),%rax
mov    %r12,-0x80(%rsp)
lea    (%rax,%rsi,8),%r12
mov    0x38(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x20(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x30(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x38(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x40(%rsp)
shl    $0x21,%rsi
mov    0x28(%rsp),%rax
add    %rsi,%rax
mov    %rax,-0x50(%rsp)
add    0x20(%rsp),%rsi
mov    %rsi,-0x48(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,1),%esi
shl    $0x20,%rsi
movabs $0x300000000,%rax
add    %rax,%rsi
mov    %rsi,-0x58(%rsp)
mov    %ebp,%esi
mov    %rsi,-0x60(%rsp)
lea    (%rcx,%rbp,1),%esi
mov    %rsi,-0x68(%rsp)
lea    (%r15,%rbp,1),%esi
mov    %rsi,-0x70(%rsp)
mov    (%rsp),%rsi
add    %ebp,%esi
mov    %rsi,0xa8(%rsp)
mov    -0x8(%rsp),%rsi
add    %ebp,%esi
mov    %rsi,0xa0(%rsp)
add    0x48(%rsp),%ebp
shl    $0x20,%rbp
lea    (%rax,%rbp,1),%rsi
mov    %rsi,0x98(%rsp)
movabs $0x200000000,%rsi
add    %rsi,%rbp
mov    %rbp,-0x78(%rsp)
mov    0x8(%rsp),%rbp
lea    0x0(,%r8,4),%rbx
add    %rbp,%rbx
mov    %rbx,0x88(%rsp)
shl    $0x20,%r8
add    %r8,%rax
mov    %rax,0x90(%rsp)
add    %rsi,%r8
mov    %r8,-0x18(%rsp)
xor    %r14d,%r14d
xor    %r8d,%r8d
mov    %r10,-0x28(%rsp)
nopl   (%rax)
mov    0x80(%rsp),%rax
movslq (%rax,%r8,1),%rbp
lea    (%r10,%rbp,2),%rbp
movss  (%r11,%r8,4),%xmm0
movss  0x4(%r11,%r8,4),%xmm1
movss  (%rdx,%rbp,4),%xmm2
mov    %ebp,%r10d
or     $0x1,%r10d
movslq %r10d,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  %xmm2,(%r11,%r8,4)
movss  %xmm3,0x4(%r11,%r8,4)
movss  %xmm0,(%rdx,%rbp,4)
add    %r15d,%ebp
movss  %xmm1,(%rdx,%rbx,4)
movss  -0x4(%r9,%r8,4),%xmm0
movss  (%r9,%r8,4),%xmm1
movslq %ebp,%rbp
mov    %ebp,%ebx
movss  (%rdx,%rbp,4),%xmm2
or     $0x1,%ebx
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  %xmm2,-0x4(%r9,%r8,4)
movss  %xmm3,(%r9,%r8,4)
movss  %xmm0,(%rdx,%rbp,4)
sub    %ecx,%ebp
movss  %xmm1,(%rdx,%rbx,4)
mov    -0x50(%rsp),%rax
lea    (%rax,%r14,1),%rbx
sar    $0x1e,%rbx
or     $0x4,%rbx
mov    -0x40(%rsp),%rax
movss  (%rax,%r8,4),%xmm0
movss  (%rdx,%rbx,1),%xmm1
movslq %ebp,%rbp
mov    %ebp,%esi
or     $0x1,%esi
movss  (%rdx,%rbp,4),%xmm2
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rax,%r8,4)
movss  %xmm3,(%rdx,%rbx,1)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,(%rdx,%rsi,4)
lea    0x0(%rbp,%r15,1),%esi
mov    -0x38(%rsp),%r10
movss  (%r10,%r8,4),%xmm0
mov    -0x48(%rsp),%rax
lea    (%rax,%r14,1),%rbx
sar    $0x1e,%rbx
or     $0x4,%rbx
movss  (%rdx,%rbx,1),%xmm1
movslq %esi,%rsi
mov    %esi,%eax
or     $0x1,%eax
cltq
movss  (%rdx,%rsi,4),%xmm2
movss  (%rdx,%rax,4),%xmm3
movss  %xmm2,(%r10,%r8,4)
movss  %xmm3,(%rdx,%rbx,1)
movss  %xmm0,(%rdx,%rsi,4)
movss  %xmm1,(%rdx,%rax,4)
mov    -0x30(%rsp),%rax
mov    (%rax,%r8,4),%r10
mov    0x8(%rdx,%rsi,4),%rbx
mov    %rbx,(%rax,%r8,4)
mov    %r10,0x8(%rdx,%rsi,4)
lea    0x2(%rbp),%eax
cltq
mov    -0x20(%rsp),%r10
mov    (%r10,%r8,4),%rsi
mov    (%rdx,%rax,4),%rbx
mov    %rbx,(%r10,%r8,4)
lea    0x2(%rbp,%rcx,1),%ebp
mov    %rsi,(%rdx,%rax,4)
mov    0x88(%rsp),%rbx
mov    -0x4(%rbx,%r8,4),%rax
movslq %ebp,%rsi
mov    (%rdx,%rsi,4),%rbp
mov    %rbp,-0x4(%rbx,%r8,4)
mov    %rax,(%rdx,%rsi,4)
mov    %esi,%eax
sub    %r15d,%eax
cltq
mov    (%r12,%r8,4),%rbp
mov    (%rdx,%rax,4),%rbx
mov    %rbx,(%r12,%r8,4)
mov    %rbp,(%rdx,%rax,4)
add    %edi,%eax
mov    0x8(%r12,%r8,4),%rbp
cltq
mov    (%rdx,%rax,4),%rbx
mov    %rbx,0x8(%r12,%r8,4)
add    %edi,%esi
mov    -0x18(%rsp),%rbx
add    %r14,%rbx
sar    $0x1e,%rbx
mov    %rbp,(%rdx,%rax,4)
movss  (%rdx,%rbx,1),%xmm0
mov    0x90(%rsp),%rax
add    %r14,%rax
sar    $0x1e,%rax
movss  (%rdx,%rax,1),%xmm1
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%rbx,1)
movss  %xmm3,(%rdx,%rax,1)
movss  %xmm0,(%rdx,%rsi,4)
movss  %xmm1,0x4(%rdx,%rsi,4)
sub    %ecx,%esi
mov    -0x78(%rsp),%rax
add    %r14,%rax
sar    $0x1e,%rax
mov    0x98(%rsp),%rbp
lea    (%r14,%rbp,1),%rbx
movss  (%rdx,%rax,1),%xmm0
sar    $0x1e,%rbx
movss  (%rdx,%rbx,1),%xmm1
movslq %esi,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,(%rdx,%rax,1)
movss  %xmm3,(%rdx,%rbx,1)
movss  %xmm0,(%rdx,%rbp,4)
mov    0xa0(%rsp),%rax
add    %r8d,%eax
lea    0x0(%rbp,%r15,1),%esi
cltq
movss  %xmm1,0x4(%rdx,%rbp,4)
movss  (%rdx,%rax,4),%xmm0
mov    -0x58(%rsp),%rbx
add    %r14,%rbx
sar    $0x1e,%rbx
movss  (%rdx,%rbx,1),%xmm1
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rbx,1)
movss  %xmm0,(%rdx,%rsi,4)
mov    0xa8(%rsp),%rbx
lea    0x2(%rbx,%r8,1),%eax
movss  %xmm1,0x4(%rdx,%rsi,4)
cltq
lea    0x3(%rbx,%r8,1),%ebx
movslq %ebx,%rbx
movss  (%rdx,%rax,4),%xmm0
movss  (%rdx,%rbx,4),%xmm1
movss  -0x8(%rdx,%rsi,4),%xmm2
movss  -0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rbx,4)
movss  %xmm0,-0x8(%rdx,%rsi,4)
mov    -0x70(%rsp),%rbx
lea    0x2(%rbx,%r8,1),%eax
movss  %xmm1,-0x4(%rdx,%rsi,4)
lea    -0x2(%rbp),%esi
cltq
lea    0x3(%rbx,%r8,1),%ebx
movss  (%rdx,%rax,4),%xmm0
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm1
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rbx,4)
mov    -0x28(%rsp),%r10
movss  %xmm0,(%rdx,%rsi,4)
mov    -0x68(%rsp),%rbx
lea    0x2(%rbx,%r8,1),%eax
lea    -0x2(%rbp,%rcx,1),%ebp
cltq
movss  %xmm1,0x4(%rdx,%rsi,4)
movss  (%rdx,%rax,4),%xmm0
lea    0x3(%rbx,%r8,1),%esi
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rbp,4)
mov    -0x60(%rsp),%rsi
lea    (%rsi,%r8,1),%eax
add    $0x2,%eax
movss  %xmm1,0x4(%rdx,%rbp,4)
sub    %r15d,%ebp
cltq
add    %r8d,%esi
add    $0x3,%esi
movss  (%rdx,%rax,4),%xmm0
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rsi,4)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,0x4(%rdx,%rbp,4)
add    $0x4,%r8
add    %r13,%r14
cmp    %r8,-0x80(%rsp)
jne    14d0 <bitrv2+0x3d0>
mov    -0x10(%rsp),%r8
mov    0x60(%rsp),%r11
mov    -0x80(%rsp),%r12
mov    0x78(%rsp),%r14
mov    0x70(%rsp),%rax
jmp    1210 <bitrv2+0x110>
test   %r15d,%r15d
jle    1bc0 <bitrv2+0xac0>
movslq %ecx,%r10
movslq %edi,%r11
mov    %r15d,%r14d
lea    (%r8,%r14,4),%r15
lea    (%r11,%r10,1),%rax
mov    %rax,-0x50(%rsp)
lea    0x2(%r11,%r10,1),%eax
mov    %rax,-0x58(%rsp)
lea    (%rdx,%r11,4),%rax
mov    %rax,-0x60(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,-0x68(%rsp)
lea    (%rdx,%r10,4),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rsp)
xor    %r13d,%r13d
xor    %ebx,%ebx
mov    %r14,-0x48(%rsp)
mov    %r10,-0x20(%rsp)
mov    %r11,-0x28(%rsp)
mov    %r15,-0x30(%rsp)
jmp    1983 <bitrv2+0x883>
nopl   (%rax)
movslq (%r8,%rax,4),%rax
movslq %esi,%rbp
lea    (%rax,%rbp,1),%rsi
add    %rbp,%rax
add    $0x2,%rax
movss  0x8(%rdx,%rsi,4),%xmm0
movslq %esi,%r12
lea    (%rsi,%rdi,1),%ebp
movss  0xc(%rdx,%r12,4),%xmm1
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm2
movss  0x4(%rdx,%rbp,4),%xmm3
movss  %xmm2,0x8(%rdx,%rsi,4)
movss  %xmm3,0xc(%rdx,%r12,4)
movss  %xmm0,(%rdx,%rbp,4)
movss  %xmm1,0x4(%rdx,%rbp,4)
add    %ecx,%eax
add    %ecx,%ebp
cltq
mov    (%rdx,%rax,4),%r12
movslq %ebp,%rsi
movss  (%rdx,%rsi,4),%xmm0
movss  0x4(%rdx,%rsi,4),%xmm1
movss  %xmm0,(%rdx,%rax,4)
movss  %xmm1,0x4(%rdx,%rax,4)
mov    %r12,(%rdx,%rsi,4)
add    $0x1,%rbx
add    $0x4,%r13
cmp    %r14,%rbx
je     1bc0 <bitrv2+0xac0>
lea    (%rbx,%r14,1),%rax
mov    $0x0,%esi
test   %rbx,%rbx
je     1900 <bitrv2+0x800>
mov    %rdi,%r9
mov    %r13,-0x80(%rsp)
mov    %rcx,%r12
mov    %rax,-0x40(%rsp)
mov    (%r8,%rax,4),%r10d
mov    %rbx,-0x38(%rsp)
movslq %ebx,%rax
shl    $0x2,%rax
mov    %rax,-0x78(%rsp)
movslq %r10d,%rax
mov    -0x50(%rsp),%rcx
lea    (%rcx,%rax,1),%r11
mov    -0x68(%rsp),%rcx
lea    (%rcx,%r11,4),%r14
shl    $0x20,%r11
movabs $0x300000000,%rcx
add    %rcx,%r11
lea    (%r12,%rax,1),%r15d
mov    -0x58(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,-0x18(%rsp)
mov    -0x60(%rsp),%rcx
lea    (%rcx,%rax,4),%r8
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,4),%r13
lea    (%rdx,%rax,4),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    -0x30(%rsp),%rax
movslq (%rax,%rbp,1),%rax
add    -0x78(%rsp),%rax
movss  (%rsi,%rbp,4),%xmm0
movss  0x4(%rsi,%rbp,4),%xmm1
movss  (%rdx,%rax,4),%xmm2
movslq %eax,%rdi
movss  0x4(%rdx,%rdi,4),%xmm3
movss  %xmm2,(%rsi,%rbp,4)
movss  %xmm3,0x4(%rsi,%rbp,4)
movss  %xmm0,(%rdx,%rax,4)
movss  %xmm1,0x4(%rdx,%rdi,4)
lea    (%rdi,%r12,1),%eax
mov    -0x4(%r13,%rbp,4),%rcx
movslq %eax,%rbx
mov    (%rdx,%rbx,4),%rax
mov    %rax,-0x4(%r13,%rbp,4)
mov    %rcx,(%rdx,%rbx,4)
mov    -0x20(%rsp),%rax
lea    0x2(%rdi,%rax,1),%eax
mov    -0x4(%r14,%rbp,4),%rcx
mov    0x8(%rdx,%rbx,4),%rdi
mov    %rdi,-0x4(%r14,%rbp,4)
mov    %rcx,0x8(%rdx,%rbx,4)
sub    %r12d,%eax
mov    (%r8,%rbp,4),%rcx
cltq
mov    (%rdx,%rax,4),%rdi
mov    %rdi,(%r8,%rbp,4)
mov    %rcx,(%rdx,%rax,4)
add    %r9d,%eax
mov    0x8(%r8,%rbp,4),%rcx
cltq
mov    (%rdx,%rax,4),%rdi
mov    %rdi,0x8(%r8,%rbp,4)
mov    %rcx,(%rdx,%rax,4)
mov    -0x18(%rsp),%rax
add    %ebp,%eax
mov    -0x28(%rsp),%rcx
lea    0x2(%rcx,%rbx,1),%ecx
cltq
movss  (%rdx,%rax,4),%xmm0
mov    %r11,%rdi
sar    $0x1e,%rdi
movss  (%rdx,%rdi,1),%xmm1
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm2
movss  0x4(%rdx,%rcx,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rdi,1)
movss  %xmm0,(%rdx,%rcx,4)
movss  %xmm1,0x4(%rdx,%rcx,4)
lea    (%r15,%rbp,1),%eax
add    $0x2,%eax
add    %r9d,%ebx
cltq
movss  (%rdx,%rax,4),%xmm0
lea    (%r15,%rbp,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm1
movslq %ebx,%rdi
movss  (%rdx,%rdi,4),%xmm2
movss  0x4(%rdx,%rdi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rcx,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  %xmm1,0x4(%rdx,%rdi,4)
lea    (%r10,%rbp,1),%eax
add    $0x2,%eax
sub    %r12d,%edi
cltq
movss  (%rdx,%rax,4),%xmm0
lea    (%r10,%rbp,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm1
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm2
movss  0x4(%rdx,%rdi,4),%xmm3
movss  %xmm2,(%rdx,%rax,4)
movss  %xmm3,(%rdx,%rcx,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  %xmm1,0x4(%rdx,%rdi,4)
add    $0x4,%rbp
movabs $0x400000000,%rax
add    %rax,%r11
cmp    %rbp,-0x80(%rsp)
jne    1a10 <bitrv2+0x910>
mov    -0x10(%rsp),%r8
mov    %r9,%rdi
mov    %r12,%rcx
mov    -0x48(%rsp),%r14
mov    -0x80(%rsp),%r13
mov    -0x38(%rsp),%rbx
mov    -0x40(%rsp),%rax
mov    -0x78(%rsp),%rsi
jmp    1900 <bitrv2+0x800>
add    $0xb0,%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 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
store i32 1, i32* %12
%19 = load i32, i32* %4
%20 = ashr i32 %19, 2
store i32 %20, i32* %11
br label %21
21: ; preds = %27, %3
%22 = load i32, i32* %11
%23 = icmp sgt i32 %22, 8
br i1 %23, label %24, label %30
24: ; preds = %21
%25 = load i32, i32* %12
%26 = shl i32 %25, 1
store i32 %26, i32* %12
br label %27
27: ; preds = %24
%28 = load i32, i32* %11
%29 = ashr i32 %28, 2
store i32 %29, i32* %11
br label %21
30: ; preds = %21
%31 = load i32, i32* %4
%32 = ashr i32 %31, 1
store i32 %32, i32* %13
%33 = load i32, i32* %12
%34 = mul nsw i32 4, %33
store i32 %34, i32* %14
%35 = load i32, i32* %11
%36 = icmp eq i32 %35, 8
br i1 %36, label %37, label %1193
37: ; preds = %30
store i32 0, i32* %9
br label %38
38: ; preds = %1189, %37
%39 = load i32, i32* %9
%40 = load i32, i32* %12
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %1192
42: ; preds = %38
store i32 0, i32* %7
br label %43
43: ; preds = %869, %42
%44 = load i32, i32* %7
%45 = load i32, i32* %9
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %872
47: ; preds = %43
%48 = load i32, i32* %7
%49 = mul nsw i32 4, %48
%50 = load i32*, i32** %5
%51 = load i32, i32* %12
%52 = load i32, i32* %9
%53 = add nsw i32 %51, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %50, i64 %54
%56 = load i32, i32* %55
%57 = mul nsw i32 2, %56
%58 = add nsw i32 %49, %57
store i32 %58, i32* %8
%59 = load i32, i32* %9
%60 = mul nsw i32 4, %59
%61 = load i32*, i32** %5
%62 = load i32, i32* %12
%63 = load i32, i32* %7
%64 = add nsw i32 %62, %63
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32, i32* %61, i64 %65
%67 = load i32, i32* %66
%68 = mul nsw i32 2, %67
%69 = add nsw i32 %60, %68
store i32 %69, i32* %10
%70 = load float*, float** %6
%71 = load i32, i32* %8
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
store float %74, float* %15
%75 = load float*, float** %6
%76 = load i32, i32* %8
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %75, i64 %78
%80 = load float, float* %79
store float %80, float* %16
%81 = load float*, float** %6
%82 = load i32, i32* %10
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %81, i64 %83
%85 = load float, float* %84
store float %85, float* %17
%86 = load float*, float** %6
%87 = load i32, i32* %10
%88 = add nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %86, i64 %89
%91 = load float, float* %90
store float %91, float* %18
%92 = load float, float* %17
%93 = load float*, float** %6
%94 = load i32, i32* %8
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %93, i64 %95
store float %92, float* %96
%97 = load float, float* %18
%98 = load float*, float** %6
%99 = load i32, i32* %8
%100 = add nsw i32 %99, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %98, i64 %101
store float %97, float* %102
%103 = load float, float* %15
%104 = load float*, float** %6
%105 = load i32, i32* %10
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
store float %103, float* %107
%108 = load float, float* %16
%109 = load float*, float** %6
%110 = load i32, i32* %10
%111 = add nsw i32 %110, 1
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %109, i64 %112
store float %108, float* %113
%114 = load i32, i32* %14
%115 = load i32, i32* %8
%116 = add nsw i32 %115, %114
store i32 %116, i32* %8
%117 = load i32, i32* %14
%118 = mul nsw i32 2, %117
%119 = load i32, i32* %10
%120 = add nsw i32 %119, %118
store i32 %120, i32* %10
%121 = load float*, float** %6
%122 = load i32, i32* %8
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
%125 = load float, float* %124
store float %125, float* %15
%126 = load float*, float** %6
%127 = load i32, i32* %8
%128 = add nsw i32 %127, 1
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %126, i64 %129
%131 = load float, float* %130
store float %131, float* %16
%132 = load float*, float** %6
%133 = load i32, i32* %10
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds float, float* %132, i64 %134
%136 = load float, float* %135
store float %136, float* %17
%137 = load float*, float** %6
%138 = load i32, i32* %10
%139 = add nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %137, i64 %140
%142 = load float, float* %141
store float %142, float* %18
%143 = load float, float* %17
%144 = load float*, float** %6
%145 = load i32, i32* %8
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
store float %143, float* %147
%148 = load float, float* %18
%149 = load float*, float** %6
%150 = load i32, i32* %8
%151 = add nsw i32 %150, 1
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %149, i64 %152
store float %148, float* %153
%154 = load float, float* %15
%155 = load float*, float** %6
%156 = load i32, i32* %10
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %155, i64 %157
store float %154, float* %158
%159 = load float, float* %16
%160 = load float*, float** %6
%161 = load i32, i32* %10
%162 = add nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %160, i64 %163
store float %159, float* %164
%165 = load i32, i32* %14
%166 = load i32, i32* %8
%167 = add nsw i32 %166, %165
store i32 %167, i32* %8
%168 = load i32, i32* %14
%169 = load i32, i32* %10
%170 = sub nsw i32 %169, %168
store i32 %170, i32* %10
%171 = load float*, float** %6
%172 = load i32, i32* %8
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %171, i64 %173
%175 = load float, float* %174
store float %175, float* %15
%176 = load float*, float** %6
%177 = load i32, i32* %8
%178 = add nsw i32 %177, 1
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %176, i64 %179
%181 = load float, float* %180
store float %181, float* %16
%182 = load float*, float** %6
%183 = load i32, i32* %10
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds float, float* %182, i64 %184
%186 = load float, float* %185
store float %186, float* %17
%187 = load float*, float** %6
%188 = load i32, i32* %10
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %187, i64 %190
%192 = load float, float* %191
store float %192, float* %18
%193 = load float, float* %17
%194 = load float*, float** %6
%195 = load i32, i32* %8
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %194, i64 %196
store float %193, float* %197
%198 = load float, float* %18
%199 = load float*, float** %6
%200 = load i32, i32* %8
%201 = add nsw i32 %200, 1
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %199, i64 %202
store float %198, float* %203
%204 = load float, float* %15
%205 = load float*, float** %6
%206 = load i32, i32* %10
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
store float %204, float* %208
%209 = load float, float* %16
%210 = load float*, float** %6
%211 = load i32, i32* %10
%212 = add nsw i32 %211, 1
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %210, i64 %213
store float %209, float* %214
%215 = load i32, i32* %14
%216 = load i32, i32* %8
%217 = add nsw i32 %216, %215
store i32 %217, i32* %8
%218 = load i32, i32* %14
%219 = mul nsw i32 2, %218
%220 = load i32, i32* %10
%221 = add nsw i32 %220, %219
store i32 %221, i32* %10
%222 = load float*, float** %6
%223 = load i32, i32* %8
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %222, i64 %224
%226 = load float, float* %225
store float %226, float* %15
%227 = load float*, float** %6
%228 = load i32, i32* %8
%229 = add nsw i32 %228, 1
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %227, i64 %230
%232 = load float, float* %231
store float %232, float* %16
%233 = load float*, float** %6
%234 = load i32, i32* %10
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float, float* %233, i64 %235
%237 = load float, float* %236
store float %237, float* %17
%238 = load float*, float** %6
%239 = load i32, i32* %10
%240 = add nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %238, i64 %241
%243 = load float, float* %242
store float %243, float* %18
%244 = load float, float* %17
%245 = load float*, float** %6
%246 = load i32, i32* %8
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
store float %244, float* %248
%249 = load float, float* %18
%250 = load float*, float** %6
%251 = load i32, i32* %8
%252 = add nsw i32 %251, 1
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds float, float* %250, i64 %253
store float %249, float* %254
%255 = load float, float* %15
%256 = load float*, float** %6
%257 = load i32, i32* %10
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float, float* %256, i64 %258
store float %255, float* %259
%260 = load float, float* %16
%261 = load float*, float** %6
%262 = load i32, i32* %10
%263 = add nsw i32 %262, 1
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %261, i64 %264
store float %260, float* %265
%266 = load i32, i32* %13
%267 = load i32, i32* %8
%268 = add nsw i32 %267, %266
store i32 %268, i32* %8
%269 = load i32, i32* %10
%270 = add nsw i32 %269, 2
store i32 %270, i32* %10
%271 = load float*, float** %6
%272 = load i32, i32* %8
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float, float* %271, i64 %273
%275 = load float, float* %274
store float %275, float* %15
%276 = load float*, float** %6
%277 = load i32, i32* %8
%278 = add nsw i32 %277, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %276, i64 %279
%281 = load float, float* %280
store float %281, float* %16
%282 = load float*, float** %6
%283 = load i32, i32* %10
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
%286 = load float, float* %285
store float %286, float* %17
%287 = load float*, float** %6
%288 = load i32, i32* %10
%289 = add nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float, float* %287, i64 %290
%292 = load float, float* %291
store float %292, float* %18
%293 = load float, float* %17
%294 = load float*, float** %6
%295 = load i32, i32* %8
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %294, i64 %296
store float %293, float* %297
%298 = load float, float* %18
%299 = load float*, float** %6
%300 = load i32, i32* %8
%301 = add nsw i32 %300, 1
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float, float* %299, i64 %302
store float %298, float* %303
%304 = load float, float* %15
%305 = load float*, float** %6
%306 = load i32, i32* %10
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %305, i64 %307
store float %304, float* %308
%309 = load float, float* %16
%310 = load float*, float** %6
%311 = load i32, i32* %10
%312 = add nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %310, i64 %313
store float %309, float* %314
%315 = load i32, i32* %14
%316 = load i32, i32* %8
%317 = sub nsw i32 %316, %315
store i32 %317, i32* %8
%318 = load i32, i32* %14
%319 = mul nsw i32 2, %318
%320 = load i32, i32* %10
%321 = sub nsw i32 %320, %319
store i32 %321, i32* %10
%322 = load float*, float** %6
%323 = load i32, i32* %8
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %322, i64 %324
%326 = load float, float* %325
store float %326, float* %15
%327 = load float*, float** %6
%328 = load i32, i32* %8
%329 = add nsw i32 %328, 1
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %327, i64 %330
%332 = load float, float* %331
store float %332, float* %16
%333 = load float*, float** %6
%334 = load i32, i32* %10
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
%337 = load float, float* %336
store float %337, float* %17
%338 = load float*, float** %6
%339 = load i32, i32* %10
%340 = add nsw i32 %339, 1
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %338, i64 %341
%343 = load float, float* %342
store float %343, float* %18
%344 = load float, float* %17
%345 = load float*, float** %6
%346 = load i32, i32* %8
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %345, i64 %347
store float %344, float* %348
%349 = load float, float* %18
%350 = load float*, float** %6
%351 = load i32, i32* %8
%352 = add nsw i32 %351, 1
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %350, i64 %353
store float %349, float* %354
%355 = load float, float* %15
%356 = load float*, float** %6
%357 = load i32, i32* %10
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float, float* %356, i64 %358
store float %355, float* %359
%360 = load float, float* %16
%361 = load float*, float** %6
%362 = load i32, i32* %10
%363 = add nsw i32 %362, 1
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds float, float* %361, i64 %364
store float %360, float* %365
%366 = load i32, i32* %14
%367 = load i32, i32* %8
%368 = sub nsw i32 %367, %366
store i32 %368, i32* %8
%369 = load i32, i32* %14
%370 = load i32, i32* %10
%371 = add nsw i32 %370, %369
store i32 %371, i32* %10
%372 = load float*, float** %6
%373 = load i32, i32* %8
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %372, i64 %374
%376 = load float, float* %375
store float %376, float* %15
%377 = load float*, float** %6
%378 = load i32, i32* %8
%379 = add nsw i32 %378, 1
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds float, float* %377, i64 %380
%382 = load float, float* %381
store float %382, float* %16
%383 = load float*, float** %6
%384 = load i32, i32* %10
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds float, float* %383, i64 %385
%387 = load float, float* %386
store float %387, float* %17
%388 = load float*, float** %6
%389 = load i32, i32* %10
%390 = add nsw i32 %389, 1
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds float, float* %388, i64 %391
%393 = load float, float* %392
store float %393, float* %18
%394 = load float, float* %17
%395 = load float*, float** %6
%396 = load i32, i32* %8
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float, float* %395, i64 %397
store float %394, float* %398
%399 = load float, float* %18
%400 = load float*, float** %6
%401 = load i32, i32* %8
%402 = add nsw i32 %401, 1
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float, float* %400, i64 %403
store float %399, float* %404
%405 = load float, float* %15
%406 = load float*, float** %6
%407 = load i32, i32* %10
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds float, float* %406, i64 %408
store float %405, float* %409
%410 = load float, float* %16
%411 = load float*, float** %6
%412 = load i32, i32* %10
%413 = add nsw i32 %412, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds float, float* %411, i64 %414
store float %410, float* %415
%416 = load i32, i32* %14
%417 = load i32, i32* %8
%418 = sub nsw i32 %417, %416
store i32 %418, i32* %8
%419 = load i32, i32* %14
%420 = mul nsw i32 2, %419
%421 = load i32, i32* %10
%422 = sub nsw i32 %421, %420
store i32 %422, i32* %10
%423 = load float*, float** %6
%424 = load i32, i32* %8
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds float, float* %423, i64 %425
%427 = load float, float* %426
store float %427, float* %15
%428 = load float*, float** %6
%429 = load i32, i32* %8
%430 = add nsw i32 %429, 1
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %428, i64 %431
%433 = load float, float* %432
store float %433, float* %16
%434 = load float*, float** %6
%435 = load i32, i32* %10
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %434, i64 %436
%438 = load float, float* %437
store float %438, float* %17
%439 = load float*, float** %6
%440 = load i32, i32* %10
%441 = add nsw i32 %440, 1
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds float, float* %439, i64 %442
%444 = load float, float* %443
store float %444, float* %18
%445 = load float, float* %17
%446 = load float*, float** %6
%447 = load i32, i32* %8
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds float, float* %446, i64 %448
store float %445, float* %449
%450 = load float, float* %18
%451 = load float*, float** %6
%452 = load i32, i32* %8
%453 = add nsw i32 %452, 1
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds float, float* %451, i64 %454
store float %450, float* %455
%456 = load float, float* %15
%457 = load float*, float** %6
%458 = load i32, i32* %10
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
store float %456, float* %460
%461 = load float, float* %16
%462 = load float*, float** %6
%463 = load i32, i32* %10
%464 = add nsw i32 %463, 1
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %462, i64 %465
store float %461, float* %466
%467 = load i32, i32* %8
%468 = add nsw i32 %467, 2
store i32 %468, i32* %8
%469 = load i32, i32* %13
%470 = load i32, i32* %10
%471 = add nsw i32 %470, %469
store i32 %471, i32* %10
%472 = load float*, float** %6
%473 = load i32, i32* %8
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds float, float* %472, i64 %474
%476 = load float, float* %475
store float %476, float* %15
%477 = load float*, float** %6
%478 = load i32, i32* %8
%479 = add nsw i32 %478, 1
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds float, float* %477, i64 %480
%482 = load float, float* %481
store float %482, float* %16
%483 = load float*, float** %6
%484 = load i32, i32* %10
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds float, float* %483, i64 %485
%487 = load float, float* %486
store float %487, float* %17
%488 = load float*, float** %6
%489 = load i32, i32* %10
%490 = add nsw i32 %489, 1
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds float, float* %488, i64 %491
%493 = load float, float* %492
store float %493, float* %18
%494 = load float, float* %17
%495 = load float*, float** %6
%496 = load i32, i32* %8
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float, float* %495, i64 %497
store float %494, float* %498
%499 = load float, float* %18
%500 = load float*, float** %6
%501 = load i32, i32* %8
%502 = add nsw i32 %501, 1
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds float, float* %500, i64 %503
store float %499, float* %504
%505 = load float, float* %15
%506 = load float*, float** %6
%507 = load i32, i32* %10
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float, float* %506, i64 %508
store float %505, float* %509
%510 = load float, float* %16
%511 = load float*, float** %6
%512 = load i32, i32* %10
%513 = add nsw i32 %512, 1
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds float, float* %511, i64 %514
store float %510, float* %515
%516 = load i32, i32* %14
%517 = load i32, i32* %8
%518 = add nsw i32 %517, %516
store i32 %518, i32* %8
%519 = load i32, i32* %14
%520 = mul nsw i32 2, %519
%521 = load i32, i32* %10
%522 = add nsw i32 %521, %520
store i32 %522, i32* %10
%523 = load float*, float** %6
%524 = load i32, i32* %8
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float, float* %523, i64 %525
%527 = load float, float* %526
store float %527, float* %15
%528 = load float*, float** %6
%529 = load i32, i32* %8
%530 = add nsw i32 %529, 1
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds float, float* %528, i64 %531
%533 = load float, float* %532
store float %533, float* %16
%534 = load float*, float** %6
%535 = load i32, i32* %10
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds float, float* %534, i64 %536
%538 = load float, float* %537
store float %538, float* %17
%539 = load float*, float** %6
%540 = load i32, i32* %10
%541 = add nsw i32 %540, 1
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds float, float* %539, i64 %542
%544 = load float, float* %543
store float %544, float* %18
%545 = load float, float* %17
%546 = load float*, float** %6
%547 = load i32, i32* %8
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds float, float* %546, i64 %548
store float %545, float* %549
%550 = load float, float* %18
%551 = load float*, float** %6
%552 = load i32, i32* %8
%553 = add nsw i32 %552, 1
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds float, float* %551, i64 %554
store float %550, float* %555
%556 = load float, float* %15
%557 = load float*, float** %6
%558 = load i32, i32* %10
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float, float* %557, i64 %559
store float %556, float* %560
%561 = load float, float* %16
%562 = load float*, float** %6
%563 = load i32, i32* %10
%564 = add nsw i32 %563, 1
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %562, i64 %565
store float %561, float* %566
%567 = load i32, i32* %14
%568 = load i32, i32* %8
%569 = add nsw i32 %568, %567
store i32 %569, i32* %8
%570 = load i32, i32* %14
%571 = load i32, i32* %10
%572 = sub nsw i32 %571, %570
store i32 %572, i32* %10
%573 = load float*, float** %6
%574 = load i32, i32* %8
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float, float* %573, i64 %575
%577 = load float, float* %576
store float %577, float* %15
%578 = load float*, float** %6
%579 = load i32, i32* %8
%580 = add nsw i32 %579, 1
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds float, float* %578, i64 %581
%583 = load float, float* %582
store float %583, float* %16
%584 = load float*, float** %6
%585 = load i32, i32* %10
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds float, float* %584, i64 %586
%588 = load float, float* %587
store float %588, float* %17
%589 = load float*, float** %6
%590 = load i32, i32* %10
%591 = add nsw i32 %590, 1
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds float, float* %589, i64 %592
%594 = load float, float* %593
store float %594, float* %18
%595 = load float, float* %17
%596 = load float*, float** %6
%597 = load i32, i32* %8
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds float, float* %596, i64 %598
store float %595, float* %599
%600 = load float, float* %18
%601 = load float*, float** %6
%602 = load i32, i32* %8
%603 = add nsw i32 %602, 1
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds float, float* %601, i64 %604
store float %600, float* %605
%606 = load float, float* %15
%607 = load float*, float** %6
%608 = load i32, i32* %10
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds float, float* %607, i64 %609
store float %606, float* %610
%611 = load float, float* %16
%612 = load float*, float** %6
%613 = load i32, i32* %10
%614 = add nsw i32 %613, 1
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds float, float* %612, i64 %615
store float %611, float* %616
%617 = load i32, i32* %14
%618 = load i32, i32* %8
%619 = add nsw i32 %618, %617
store i32 %619, i32* %8
%620 = load i32, i32* %14
%621 = mul nsw i32 2, %620
%622 = load i32, i32* %10
%623 = add nsw i32 %622, %621
store i32 %623, i32* %10
%624 = load float*, float** %6
%625 = load i32, i32* %8
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds float, float* %624, i64 %626
%628 = load float, float* %627
store float %628, float* %15
%629 = load float*, float** %6
%630 = load i32, i32* %8
%631 = add nsw i32 %630, 1
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds float, float* %629, i64 %632
%634 = load float, float* %633
store float %634, float* %16
%635 = load float*, float** %6
%636 = load i32, i32* %10
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds float, float* %635, i64 %637
%639 = load float, float* %638
store float %639, float* %17
%640 = load float*, float** %6
%641 = load i32, i32* %10
%642 = add nsw i32 %641, 1
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds float, float* %640, i64 %643
%645 = load float, float* %644
store float %645, float* %18
%646 = load float, float* %17
%647 = load float*, float** %6
%648 = load i32, i32* %8
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds float, float* %647, i64 %649
store float %646, float* %650
%651 = load float, float* %18
%652 = load float*, float** %6
%653 = load i32, i32* %8
%654 = add nsw i32 %653, 1
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds float, float* %652, i64 %655
store float %651, float* %656
%657 = load float, float* %15
%658 = load float*, float** %6
%659 = load i32, i32* %10
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds float, float* %658, i64 %660
store float %657, float* %661
%662 = load float, float* %16
%663 = load float*, float** %6
%664 = load i32, i32* %10
%665 = add nsw i32 %664, 1
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds float, float* %663, i64 %666
store float %662, float* %667
%668 = load i32, i32* %13
%669 = load i32, i32* %8
%670 = sub nsw i32 %669, %668
store i32 %670, i32* %8
%671 = load i32, i32* %10
%672 = sub nsw i32 %671, 2
store i32 %672, i32* %10
%673 = load float*, float** %6
%674 = load i32, i32* %8
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds float, float* %673, i64 %675
%677 = load float, float* %676
store float %677, float* %15
%678 = load float*, float** %6
%679 = load i32, i32* %8
%680 = add nsw i32 %679, 1
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds float, float* %678, i64 %681
%683 = load float, float* %682
store float %683, float* %16
%684 = load float*, float** %6
%685 = load i32, i32* %10
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds float, float* %684, i64 %686
%688 = load float, float* %687
store float %688, float* %17
%689 = load float*, float** %6
%690 = load i32, i32* %10
%691 = add nsw i32 %690, 1
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds float, float* %689, i64 %692
%694 = load float, float* %693
store float %694, float* %18
%695 = load float, float* %17
%696 = load float*, float** %6
%697 = load i32, i32* %8
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds float, float* %696, i64 %698
store float %695, float* %699
%700 = load float, float* %18
%701 = load float*, float** %6
%702 = load i32, i32* %8
%703 = add nsw i32 %702, 1
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds float, float* %701, i64 %704
store float %700, float* %705
%706 = load float, float* %15
%707 = load float*, float** %6
%708 = load i32, i32* %10
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds float, float* %707, i64 %709
store float %706, float* %710
%711 = load float, float* %16
%712 = load float*, float** %6
%713 = load i32, i32* %10
%714 = add nsw i32 %713, 1
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds float, float* %712, i64 %715
store float %711, float* %716
%717 = load i32, i32* %14
%718 = load i32, i32* %8
%719 = sub nsw i32 %718, %717
store i32 %719, i32* %8
%720 = load i32, i32* %14
%721 = mul nsw i32 2, %720
%722 = load i32, i32* %10
%723 = sub nsw i32 %722, %721
store i32 %723, i32* %10
%724 = load float*, float** %6
%725 = load i32, i32* %8
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds float, float* %724, i64 %726
%728 = load float, float* %727
store float %728, float* %15
%729 = load float*, float** %6
%730 = load i32, i32* %8
%731 = add nsw i32 %730, 1
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds float, float* %729, i64 %732
%734 = load float, float* %733
store float %734, float* %16
%735 = load float*, float** %6
%736 = load i32, i32* %10
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds float, float* %735, i64 %737
%739 = load float, float* %738
store float %739, float* %17
%740 = load float*, float** %6
%741 = load i32, i32* %10
%742 = add nsw i32 %741, 1
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds float, float* %740, i64 %743
%745 = load float, float* %744
store float %745, float* %18
%746 = load float, float* %17
%747 = load float*, float** %6
%748 = load i32, i32* %8
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds float, float* %747, i64 %749
store float %746, float* %750
%751 = load float, float* %18
%752 = load float*, float** %6
%753 = load i32, i32* %8
%754 = add nsw i32 %753, 1
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds float, float* %752, i64 %755
store float %751, float* %756
%757 = load float, float* %15
%758 = load float*, float** %6
%759 = load i32, i32* %10
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %758, i64 %760
store float %757, float* %761
%762 = load float, float* %16
%763 = load float*, float** %6
%764 = load i32, i32* %10
%765 = add nsw i32 %764, 1
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds float, float* %763, i64 %766
store float %762, float* %767
%768 = load i32, i32* %14
%769 = load i32, i32* %8
%770 = sub nsw i32 %769, %768
store i32 %770, i32* %8
%771 = load i32, i32* %14
%772 = load i32, i32* %10
%773 = add nsw i32 %772, %771
store i32 %773, i32* %10
%774 = load float*, float** %6
%775 = load i32, i32* %8
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds float, float* %774, i64 %776
%778 = load float, float* %777
store float %778, float* %15
%779 = load float*, float** %6
%780 = load i32, i32* %8
%781 = add nsw i32 %780, 1
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds float, float* %779, i64 %782
%784 = load float, float* %783
store float %784, float* %16
%785 = load float*, float** %6
%786 = load i32, i32* %10
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds float, float* %785, i64 %787
%789 = load float, float* %788
store float %789, float* %17
%790 = load float*, float** %6
%791 = load i32, i32* %10
%792 = add nsw i32 %791, 1
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds float, float* %790, i64 %793
%795 = load float, float* %794
store float %795, float* %18
%796 = load float, float* %17
%797 = load float*, float** %6
%798 = load i32, i32* %8
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds float, float* %797, i64 %799
store float %796, float* %800
%801 = load float, float* %18
%802 = load float*, float** %6
%803 = load i32, i32* %8
%804 = add nsw i32 %803, 1
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds float, float* %802, i64 %805
store float %801, float* %806
%807 = load float, float* %15
%808 = load float*, float** %6
%809 = load i32, i32* %10
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds float, float* %808, i64 %810
store float %807, float* %811
%812 = load float, float* %16
%813 = load float*, float** %6
%814 = load i32, i32* %10
%815 = add nsw i32 %814, 1
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds float, float* %813, i64 %816
store float %812, float* %817
%818 = load i32, i32* %14
%819 = load i32, i32* %8
%820 = sub nsw i32 %819, %818
store i32 %820, i32* %8
%821 = load i32, i32* %14
%822 = mul nsw i32 2, %821
%823 = load i32, i32* %10
%824 = sub nsw i32 %823, %822
store i32 %824, i32* %10
%825 = load float*, float** %6
%826 = load i32, i32* %8
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds float, float* %825, i64 %827
%829 = load float, float* %828
store float %829, float* %15
%830 = load float*, float** %6
%831 = load i32, i32* %8
%832 = add nsw i32 %831, 1
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %830, i64 %833
%835 = load float, float* %834
store float %835, float* %16
%836 = load float*, float** %6
%837 = load i32, i32* %10
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float, float* %836, i64 %838
%840 = load float, float* %839
store float %840, float* %17
%841 = load float*, float** %6
%842 = load i32, i32* %10
%843 = add nsw i32 %842, 1
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds float, float* %841, i64 %844
%846 = load float, float* %845
store float %846, float* %18
%847 = load float, float* %17
%848 = load float*, float** %6
%849 = load i32, i32* %8
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds float, float* %848, i64 %850
store float %847, float* %851
%852 = load float, float* %18
%853 = load float*, float** %6
%854 = load i32, i32* %8
%855 = add nsw i32 %854, 1
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds float, float* %853, i64 %856
store float %852, float* %857
%858 = load float, float* %15
%859 = load float*, float** %6
%860 = load i32, i32* %10
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds float, float* %859, i64 %861
store float %858, float* %862
%863 = load float, float* %16
%864 = load float*, float** %6
%865 = load i32, i32* %10
%866 = add nsw i32 %865, 1
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds float, float* %864, i64 %867
store float %863, float* %868
br label %869
869: ; preds = %47
%870 = load i32, i32* %7
%871 = add nsw i32 %870, 1
store i32 %871, i32* %7
br label %43
872: ; preds = %43
%873 = load i32, i32* %9
%874 = mul nsw i32 4, %873
%875 = load i32*, i32** %5
%876 = load i32, i32* %12
%877 = load i32, i32* %9
%878 = add nsw i32 %876, %877
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds i32, i32* %875, i64 %879
%881 = load i32, i32* %880
%882 = mul nsw i32 2, %881
%883 = add nsw i32 %874, %882
store i32 %883, i32* %10
%884 = load i32, i32* %10
%885 = add nsw i32 %884, 2
store i32 %885, i32* %8
%886 = load i32, i32* %13
%887 = load i32, i32* %10
%888 = add nsw i32 %887, %886
store i32 %888, i32* %10
%889 = load float*, float** %6
%890 = load i32, i32* %8
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds float, float* %889, i64 %891
%893 = load float, float* %892
store float %893, float* %15
%894 = load float*, float** %6
%895 = load i32, i32* %8
%896 = add nsw i32 %895, 1
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds float, float* %894, i64 %897
%899 = load float, float* %898
store float %899, float* %16
%900 = load float*, float** %6
%901 = load i32, i32* %10
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds float, float* %900, i64 %902
%904 = load float, float* %903
store float %904, float* %17
%905 = load float*, float** %6
%906 = load i32, i32* %10
%907 = add nsw i32 %906, 1
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds float, float* %905, i64 %908
%910 = load float, float* %909
store float %910, float* %18
%911 = load float, float* %17
%912 = load float*, float** %6
%913 = load i32, i32* %8
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds float, float* %912, i64 %914
store float %911, float* %915
%916 = load float, float* %18
%917 = load float*, float** %6
%918 = load i32, i32* %8
%919 = add nsw i32 %918, 1
%920 = sext i32 %919 to i64
%921 = getelementptr inbounds float, float* %917, i64 %920
store float %916, float* %921
%922 = load float, float* %15
%923 = load float*, float** %6
%924 = load i32, i32* %10
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds float, float* %923, i64 %925
store float %922, float* %926
%927 = load float, float* %16
%928 = load float*, float** %6
%929 = load i32, i32* %10
%930 = add nsw i32 %929, 1
%931 = sext i32 %930 to i64
%932 = getelementptr inbounds float, float* %928, i64 %931
store float %927, float* %932
%933 = load i32, i32* %14
%934 = load i32, i32* %8
%935 = add nsw i32 %934, %933
store i32 %935, i32* %8
%936 = load i32, i32* %14
%937 = mul nsw i32 2, %936
%938 = load i32, i32* %10
%939 = add nsw i32 %938, %937
store i32 %939, i32* %10
%940 = load float*, float** %6
%941 = load i32, i32* %8
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds float, float* %940, i64 %942
%944 = load float, float* %943
store float %944, float* %15
%945 = load float*, float** %6
%946 = load i32, i32* %8
%947 = add nsw i32 %946, 1
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds float, float* %945, i64 %948
%950 = load float, float* %949
store float %950, float* %16
%951 = load float*, float** %6
%952 = load i32, i32* %10
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds float, float* %951, i64 %953
%955 = load float, float* %954
store float %955, float* %17
%956 = load float*, float** %6
%957 = load i32, i32* %10
%958 = add nsw i32 %957, 1
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds float, float* %956, i64 %959
%961 = load float, float* %960
store float %961, float* %18
%962 = load float, float* %17
%963 = load float*, float** %6
%964 = load i32, i32* %8
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds float, float* %963, i64 %965
store float %962, float* %966
%967 = load float, float* %18
%968 = load float*, float** %6
%969 = load i32, i32* %8
%970 = add nsw i32 %969, 1
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds float, float* %968, i64 %971
store float %967, float* %972
%973 = load float, float* %15
%974 = load float*, float** %6
%975 = load i32, i32* %10
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds float, float* %974, i64 %976
store float %973, float* %977
%978 = load float, float* %16
%979 = load float*, float** %6
%980 = load i32, i32* %10
%981 = add nsw i32 %980, 1
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds float, float* %979, i64 %982
store float %978, float* %983
%984 = load i32, i32* %14
%985 = load i32, i32* %8
%986 = add nsw i32 %985, %984
store i32 %986, i32* %8
%987 = load i32, i32* %14
%988 = load i32, i32* %10
%989 = sub nsw i32 %988, %987
store i32 %989, i32* %10
%990 = load float*, float** %6
%991 = load i32, i32* %8
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds float, float* %990, i64 %992
%994 = load float, float* %993
store float %994, float* %15
%995 = load float*, float** %6
%996 = load i32, i32* %8
%997 = add nsw i32 %996, 1
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds float, float* %995, i64 %998
%1000 = load float, float* %999
store float %1000, float* %16
%1001 = load float*, float** %6
%1002 = load i32, i32* %10
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds float, float* %1001, i64 %1003
%1005 = load float, float* %1004
store float %1005, float* %17
%1006 = load float*, float** %6
%1007 = load i32, i32* %10
%1008 = add nsw i32 %1007, 1
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds float, float* %1006, i64 %1009
%1011 = load float, float* %1010
store float %1011, float* %18
%1012 = load float, float* %17
%1013 = load float*, float** %6
%1014 = load i32, i32* %8
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds float, float* %1013, i64 %1015
store float %1012, float* %1016
%1017 = load float, float* %18
%1018 = load float*, float** %6
%1019 = load i32, i32* %8
%1020 = add nsw i32 %1019, 1
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds float, float* %1018, i64 %1021
store float %1017, float* %1022
%1023 = load float, float* %15
%1024 = load float*, float** %6
%1025 = load i32, i32* %10
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds float, float* %1024, i64 %1026
store float %1023, float* %1027
%1028 = load float, float* %16
%1029 = load float*, float** %6
%1030 = load i32, i32* %10
%1031 = add nsw i32 %1030, 1
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds float, float* %1029, i64 %1032
store float %1028, float* %1033
%1034 = load i32, i32* %8
%1035 = sub nsw i32 %1034, 2
store i32 %1035, i32* %8
%1036 = load i32, i32* %13
%1037 = load i32, i32* %10
%1038 = sub nsw i32 %1037, %1036
store i32 %1038, i32* %10
%1039 = load float*, float** %6
%1040 = load i32, i32* %8
%1041 = sext i32 %1040 to i64
%1042 = getelementptr inbounds float, float* %1039, i64 %1041
%1043 = load float, float* %1042
store float %1043, float* %15
%1044 = load float*, float** %6
%1045 = load i32, i32* %8
%1046 = add nsw i32 %1045, 1
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds float, float* %1044, i64 %1047
%1049 = load float, float* %1048
store float %1049, float* %16
%1050 = load float*, float** %6
%1051 = load i32, i32* %10
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds float, float* %1050, i64 %1052
%1054 = load float, float* %1053
store float %1054, float* %17
%1055 = load float*, float** %6
%1056 = load i32, i32* %10
%1057 = add nsw i32 %1056, 1
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds float, float* %1055, i64 %1058
%1060 = load float, float* %1059
store float %1060, float* %18
%1061 = load float, float* %17
%1062 = load float*, float** %6
%1063 = load i32, i32* %8
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds float, float* %1062, i64 %1064
store float %1061, float* %1065
%1066 = load float, float* %18
%1067 = load float*, float** %6
%1068 = load i32, i32* %8
%1069 = add nsw i32 %1068, 1
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds float, float* %1067, i64 %1070
store float %1066, float* %1071
%1072 = load float, float* %15
%1073 = load float*, float** %6
%1074 = load i32, i32* %10
%1075 = sext i32 %1074 to i64
%1076 = getelementptr inbounds float, float* %1073, i64 %1075
store float %1072, float* %1076
%1077 = load float, float* %16
%1078 = load float*, float** %6
%1079 = load i32, i32* %10
%1080 = add nsw i32 %1079, 1
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds float, float* %1078, i64 %1081
store float %1077, float* %1082
%1083 = load i32, i32* %13
%1084 = add nsw i32 %1083, 2
%1085 = load i32, i32* %8
%1086 = add nsw i32 %1085, %1084
store i32 %1086, i32* %8
%1087 = load i32, i32* %13
%1088 = add nsw i32 %1087, 2
%1089 = load i32, i32* %10
%1090 = add nsw i32 %1089, %1088
store i32 %1090, i32* %10
%1091 = load float*, float** %6
%1092 = load i32, i32* %8
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds float, float* %1091, i64 %1093
%1095 = load float, float* %1094
store float %1095, float* %15
%1096 = load float*, float** %6
%1097 = load i32, i32* %8
%1098 = add nsw i32 %1097, 1
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds float, float* %1096, i64 %1099
%1101 = load float, float* %1100
store float %1101, float* %16
%1102 = load float*, float** %6
%1103 = load i32, i32* %10
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds float, float* %1102, i64 %1104
%1106 = load float, float* %1105
store float %1106, float* %17
%1107 = load float*, float** %6
%1108 = load i32, i32* %10
%1109 = add nsw i32 %1108, 1
%1110 = sext i32 %1109 to i64
%1111 = getelementptr inbounds float, float* %1107, i64 %1110
%1112 = load float, float* %1111
store float %1112, float* %18
%1113 = load float, float* %17
%1114 = load float*, float** %6
%1115 = load i32, i32* %8
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds float, float* %1114, i64 %1116
store float %1113, float* %1117
%1118 = load float, float* %18
%1119 = load float*, float** %6
%1120 = load i32, i32* %8
%1121 = add nsw i32 %1120, 1
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds float, float* %1119, i64 %1122
store float %1118, float* %1123
%1124 = load float, float* %15
%1125 = load float*, float** %6
%1126 = load i32, i32* %10
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds float, float* %1125, i64 %1127
store float %1124, float* %1128
%1129 = load float, float* %16
%1130 = load float*, float** %6
%1131 = load i32, i32* %10
%1132 = add nsw i32 %1131, 1
%1133 = sext i32 %1132 to i64
%1134 = getelementptr inbounds float, float* %1130, i64 %1133
store float %1129, float* %1134
%1135 = load i32, i32* %13
%1136 = load i32, i32* %14
%1137 = sub nsw i32 %1135, %1136
%1138 = load i32, i32* %8
%1139 = sub nsw i32 %1138, %1137
store i32 %1139, i32* %8
%1140 = load i32, i32* %14
%1141 = mul nsw i32 2, %1140
%1142 = sub nsw i32 %1141, 2
%1143 = load i32, i32* %10
%1144 = add nsw i32 %1143, %1142
store i32 %1144, i32* %10
%1145 = load float*, float** %6
%1146 = load i32, i32* %8
%1147 = sext i32 %1146 to i64
%1148 = getelementptr inbounds float, float* %1145, i64 %1147
%1149 = load float, float* %1148
store float %1149, float* %15
%1150 = load float*, float** %6
%1151 = load i32, i32* %8
%1152 = add nsw i32 %1151, 1
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds float, float* %1150, i64 %1153
%1155 = load float, float* %1154
store float %1155, float* %16
%1156 = load float*, float** %6
%1157 = load i32, i32* %10
%1158 = sext i32 %1157 to i64
%1159 = getelementptr inbounds float, float* %1156, i64 %1158
%1160 = load float, float* %1159
store float %1160, float* %17
%1161 = load float*, float** %6
%1162 = load i32, i32* %10
%1163 = add nsw i32 %1162, 1
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds float, float* %1161, i64 %1164
%1166 = load float, float* %1165
store float %1166, float* %18
%1167 = load float, float* %17
%1168 = load float*, float** %6
%1169 = load i32, i32* %8
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds float, float* %1168, i64 %1170
store float %1167, float* %1171
%1172 = load float, float* %18
%1173 = load float*, float** %6
%1174 = load i32, i32* %8
%1175 = add nsw i32 %1174, 1
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds float, float* %1173, i64 %1176
store float %1172, float* %1177
%1178 = load float, float* %15
%1179 = load float*, float** %6
%1180 = load i32, i32* %10
%1181 = sext i32 %1180 to i64
%1182 = getelementptr inbounds float, float* %1179, i64 %1181
store float %1178, float* %1182
%1183 = load float, float* %16
%1184 = load float*, float** %6
%1185 = load i32, i32* %10
%1186 = add nsw i32 %1185, 1
%1187 = sext i32 %1186 to i64
%1188 = getelementptr inbounds float, float* %1184, i64 %1187
store float %1183, float* %1188
br label %1189
1189: ; preds = %872
%1190 = load i32, i32* %9
%1191 = add nsw i32 %1190, 1
store i32 %1191, i32* %9
br label %38
1192: ; preds = %38
br label %1732
1193: ; preds = %30
store i32 0, i32* %9
br label %1194
1194: ; preds = %1728, %1193
%1195 = load i32, i32* %9
%1196 = load i32, i32* %12
%1197 = icmp slt i32 %1195, %1196
br i1 %1197, label %1198, label %1731
1198: ; preds = %1194
store i32 0, i32* %7
br label %1199
1199: ; preds = %1615, %1198
%1200 = load i32, i32* %7
%1201 = load i32, i32* %9
%1202 = icmp slt i32 %1200, %1201
br i1 %1202, label %1203, label %1618
1203: ; preds = %1199
%1204 = load i32, i32* %7
%1205 = mul nsw i32 4, %1204
%1206 = load i32*, i32** %5
%1207 = load i32, i32* %12
%1208 = load i32, i32* %9
%1209 = add nsw i32 %1207, %1208
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds i32, i32* %1206, i64 %1210
%1212 = load i32, i32* %1211
%1213 = add nsw i32 %1205, %1212
store i32 %1213, i32* %8
%1214 = load i32, i32* %9
%1215 = mul nsw i32 4, %1214
%1216 = load i32*, i32** %5
%1217 = load i32, i32* %12
%1218 = load i32, i32* %7
%1219 = add nsw i32 %1217, %1218
%1220 = sext i32 %1219 to i64
%1221 = getelementptr inbounds i32, i32* %1216, i64 %1220
%1222 = load i32, i32* %1221
%1223 = add nsw i32 %1215, %1222
store i32 %1223, i32* %10
%1224 = load float*, float** %6
%1225 = load i32, i32* %8
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds float, float* %1224, i64 %1226
%1228 = load float, float* %1227
store float %1228, float* %15
%1229 = load float*, float** %6
%1230 = load i32, i32* %8
%1231 = add nsw i32 %1230, 1
%1232 = sext i32 %1231 to i64
%1233 = getelementptr inbounds float, float* %1229, i64 %1232
%1234 = load float, float* %1233
store float %1234, float* %16
%1235 = load float*, float** %6
%1236 = load i32, i32* %10
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds float, float* %1235, i64 %1237
%1239 = load float, float* %1238
store float %1239, float* %17
%1240 = load float*, float** %6
%1241 = load i32, i32* %10
%1242 = add nsw i32 %1241, 1
%1243 = sext i32 %1242 to i64
%1244 = getelementptr inbounds float, float* %1240, i64 %1243
%1245 = load float, float* %1244
store float %1245, float* %18
%1246 = load float, float* %17
%1247 = load float*, float** %6
%1248 = load i32, i32* %8
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds float, float* %1247, i64 %1249
store float %1246, float* %1250
%1251 = load float, float* %18
%1252 = load float*, float** %6
%1253 = load i32, i32* %8
%1254 = add nsw i32 %1253, 1
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds float, float* %1252, i64 %1255
store float %1251, float* %1256
%1257 = load float, float* %15
%1258 = load float*, float** %6
%1259 = load i32, i32* %10
%1260 = sext i32 %1259 to i64
%1261 = getelementptr inbounds float, float* %1258, i64 %1260
store float %1257, float* %1261
%1262 = load float, float* %16
%1263 = load float*, float** %6
%1264 = load i32, i32* %10
%1265 = add nsw i32 %1264, 1
%1266 = sext i32 %1265 to i64
%1267 = getelementptr inbounds float, float* %1263, i64 %1266
store float %1262, float* %1267
%1268 = load i32, i32* %14
%1269 = load i32, i32* %8
%1270 = add nsw i32 %1269, %1268
store i32 %1270, i32* %8
%1271 = load i32, i32* %14
%1272 = load i32, i32* %10
%1273 = add nsw i32 %1272, %1271
store i32 %1273, i32* %10
%1274 = load float*, float** %6
%1275 = load i32, i32* %8
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds float, float* %1274, i64 %1276
%1278 = load float, float* %1277
store float %1278, float* %15
%1279 = load float*, float** %6
%1280 = load i32, i32* %8
%1281 = add nsw i32 %1280, 1
%1282 = sext i32 %1281 to i64
%1283 = getelementptr inbounds float, float* %1279, i64 %1282
%1284 = load float, float* %1283
store float %1284, float* %16
%1285 = load float*, float** %6
%1286 = load i32, i32* %10
%1287 = sext i32 %1286 to i64
%1288 = getelementptr inbounds float, float* %1285, i64 %1287
%1289 = load float, float* %1288
store float %1289, float* %17
%1290 = load float*, float** %6
%1291 = load i32, i32* %10
%1292 = add nsw i32 %1291, 1
%1293 = sext i32 %1292 to i64
%1294 = getelementptr inbounds float, float* %1290, i64 %1293
%1295 = load float, float* %1294
store float %1295, float* %18
%1296 = load float, float* %17
%1297 = load float*, float** %6
%1298 = load i32, i32* %8
%1299 = sext i32 %1298 to i64
%1300 = getelementptr inbounds float, float* %1297, i64 %1299
store float %1296, float* %1300
%1301 = load float, float* %18
%1302 = load float*, float** %6
%1303 = load i32, i32* %8
%1304 = add nsw i32 %1303, 1
%1305 = sext i32 %1304 to i64
%1306 = getelementptr inbounds float, float* %1302, i64 %1305
store float %1301, float* %1306
%1307 = load float, float* %15
%1308 = load float*, float** %6
%1309 = load i32, i32* %10
%1310 = sext i32 %1309 to i64
%1311 = getelementptr inbounds float, float* %1308, i64 %1310
store float %1307, float* %1311
%1312 = load float, float* %16
%1313 = load float*, float** %6
%1314 = load i32, i32* %10
%1315 = add nsw i32 %1314, 1
%1316 = sext i32 %1315 to i64
%1317 = getelementptr inbounds float, float* %1313, i64 %1316
store float %1312, float* %1317
%1318 = load i32, i32* %13
%1319 = load i32, i32* %8
%1320 = add nsw i32 %1319, %1318
store i32 %1320, i32* %8
%1321 = load i32, i32* %10
%1322 = add nsw i32 %1321, 2
store i32 %1322, i32* %10
%1323 = load float*, float** %6
%1324 = load i32, i32* %8
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds float, float* %1323, i64 %1325
%1327 = load float, float* %1326
store float %1327, float* %15
%1328 = load float*, float** %6
%1329 = load i32, i32* %8
%1330 = add nsw i32 %1329, 1
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds float, float* %1328, i64 %1331
%1333 = load float, float* %1332
store float %1333, float* %16
%1334 = load float*, float** %6
%1335 = load i32, i32* %10
%1336 = sext i32 %1335 to i64
%1337 = getelementptr inbounds float, float* %1334, i64 %1336
%1338 = load float, float* %1337
store float %1338, float* %17
%1339 = load float*, float** %6
%1340 = load i32, i32* %10
%1341 = add nsw i32 %1340, 1
%1342 = sext i32 %1341 to i64
%1343 = getelementptr inbounds float, float* %1339, i64 %1342
%1344 = load float, float* %1343
store float %1344, float* %18
%1345 = load float, float* %17
%1346 = load float*, float** %6
%1347 = load i32, i32* %8
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds float, float* %1346, i64 %1348
store float %1345, float* %1349
%1350 = load float, float* %18
%1351 = load float*, float** %6
%1352 = load i32, i32* %8
%1353 = add nsw i32 %1352, 1
%1354 = sext i32 %1353 to i64
%1355 = getelementptr inbounds float, float* %1351, i64 %1354
store float %1350, float* %1355
%1356 = load float, float* %15
%1357 = load float*, float** %6
%1358 = load i32, i32* %10
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds float, float* %1357, i64 %1359
store float %1356, float* %1360
%1361 = load float, float* %16
%1362 = load float*, float** %6
%1363 = load i32, i32* %10
%1364 = add nsw i32 %1363, 1
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds float, float* %1362, i64 %1365
store float %1361, float* %1366
%1367 = load i32, i32* %14
%1368 = load i32, i32* %8
%1369 = sub nsw i32 %1368, %1367
store i32 %1369, i32* %8
%1370 = load i32, i32* %14
%1371 = load i32, i32* %10
%1372 = sub nsw i32 %1371, %1370
store i32 %1372, i32* %10
%1373 = load float*, float** %6
%1374 = load i32, i32* %8
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds float, float* %1373, i64 %1375
%1377 = load float, float* %1376
store float %1377, float* %15
%1378 = load float*, float** %6
%1379 = load i32, i32* %8
%1380 = add nsw i32 %1379, 1
%1381 = sext i32 %1380 to i64
%1382 = getelementptr inbounds float, float* %1378, i64 %1381
%1383 = load float, float* %1382
store float %1383, float* %16
%1384 = load float*, float** %6
%1385 = load i32, i32* %10
%1386 = sext i32 %1385 to i64
%1387 = getelementptr inbounds float, float* %1384, i64 %1386
%1388 = load float, float* %1387
store float %1388, float* %17
%1389 = load float*, float** %6
%1390 = load i32, i32* %10
%1391 = add nsw i32 %1390, 1
%1392 = sext i32 %1391 to i64
%1393 = getelementptr inbounds float, float* %1389, i64 %1392
%1394 = load float, float* %1393
store float %1394, float* %18
%1395 = load float, float* %17
%1396 = load float*, float** %6
%1397 = load i32, i32* %8
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds float, float* %1396, i64 %1398
store float %1395, float* %1399
%1400 = load float, float* %18
%1401 = load float*, float** %6
%1402 = load i32, i32* %8
%1403 = add nsw i32 %1402, 1
%1404 = sext i32 %1403 to i64
%1405 = getelementptr inbounds float, float* %1401, i64 %1404
store float %1400, float* %1405
%1406 = load float, float* %15
%1407 = load float*, float** %6
%1408 = load i32, i32* %10
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds float, float* %1407, i64 %1409
store float %1406, float* %1410
%1411 = load float, float* %16
%1412 = load float*, float** %6
%1413 = load i32, i32* %10
%1414 = add nsw i32 %1413, 1
%1415 = sext i32 %1414 to i64
%1416 = getelementptr inbounds float, float* %1412, i64 %1415
store float %1411, float* %1416
%1417 = load i32, i32* %8
%1418 = add nsw i32 %1417, 2
store i32 %1418, i32* %8
%1419 = load i32, i32* %13
%1420 = load i32, i32* %10
%1421 = add nsw i32 %1420, %1419
store i32 %1421, i32* %10
%1422 = load float*, float** %6
%1423 = load i32, i32* %8
%1424 = sext i32 %1423 to i64
%1425 = getelementptr inbounds float, float* %1422, i64 %1424
%1426 = load float, float* %1425
store float %1426, float* %15
%1427 = load float*, float** %6
%1428 = load i32, i32* %8
%1429 = add nsw i32 %1428, 1
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds float, float* %1427, i64 %1430
%1432 = load float, float* %1431
store float %1432, float* %16
%1433 = load float*, float** %6
%1434 = load i32, i32* %10
%1435 = sext i32 %1434 to i64
%1436 = getelementptr inbounds float, float* %1433, i64 %1435
%1437 = load float, float* %1436
store float %1437, float* %17
%1438 = load float*, float** %6
%1439 = load i32, i32* %10
%1440 = add nsw i32 %1439, 1
%1441 = sext i32 %1440 to i64
%1442 = getelementptr inbounds float, float* %1438, i64 %1441
%1443 = load float, float* %1442
store float %1443, float* %18
%1444 = load float, float* %17
%1445 = load float*, float** %6
%1446 = load i32, i32* %8
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds float, float* %1445, i64 %1447
store float %1444, float* %1448
%1449 = load float, float* %18
%1450 = load float*, float** %6
%1451 = load i32, i32* %8
%1452 = add nsw i32 %1451, 1
%1453 = sext i32 %1452 to i64
%1454 = getelementptr inbounds float, float* %1450, i64 %1453
store float %1449, float* %1454
%1455 = load float, float* %15
%1456 = load float*, float** %6
%1457 = load i32, i32* %10
%1458 = sext i32 %1457 to i64
%1459 = getelementptr inbounds float, float* %1456, i64 %1458
store float %1455, float* %1459
%1460 = load float, float* %16
%1461 = load float*, float** %6
%1462 = load i32, i32* %10
%1463 = add nsw i32 %1462, 1
%1464 = sext i32 %1463 to i64
%1465 = getelementptr inbounds float, float* %1461, i64 %1464
store float %1460, float* %1465
%1466 = load i32, i32* %14
%1467 = load i32, i32* %8
%1468 = add nsw i32 %1467, %1466
store i32 %1468, i32* %8
%1469 = load i32, i32* %14
%1470 = load i32, i32* %10
%1471 = add nsw i32 %1470, %1469
store i32 %1471, i32* %10
%1472 = load float*, float** %6
%1473 = load i32, i32* %8
%1474 = sext i32 %1473 to i64
%1475 = getelementptr inbounds float, float* %1472, i64 %1474
%1476 = load float, float* %1475
store float %1476, float* %15
%1477 = load float*, float** %6
%1478 = load i32, i32* %8
%1479 = add nsw i32 %1478, 1
%1480 = sext i32 %1479 to i64
%1481 = getelementptr inbounds float, float* %1477, i64 %1480
%1482 = load float, float* %1481
store float %1482, float* %16
%1483 = load float*, float** %6
%1484 = load i32, i32* %10
%1485 = sext i32 %1484 to i64
%1486 = getelementptr inbounds float, float* %1483, i64 %1485
%1487 = load float, float* %1486
store float %1487, float* %17
%1488 = load float*, float** %6
%1489 = load i32, i32* %10
%1490 = add nsw i32 %1489, 1
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds float, float* %1488, i64 %1491
%1493 = load float, float* %1492
store float %1493, float* %18
%1494 = load float, float* %17
%1495 = load float*, float** %6
%1496 = load i32, i32* %8
%1497 = sext i32 %1496 to i64
%1498 = getelementptr inbounds float, float* %1495, i64 %1497
store float %1494, float* %1498
%1499 = load float, float* %18
%1500 = load float*, float** %6
%1501 = load i32, i32* %8
%1502 = add nsw i32 %1501, 1
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds float, float* %1500, i64 %1503
store float %1499, float* %1504
%1505 = load float, float* %15
%1506 = load float*, float** %6
%1507 = load i32, i32* %10
%1508 = sext i32 %1507 to i64
%1509 = getelementptr inbounds float, float* %1506, i64 %1508
store float %1505, float* %1509
%1510 = load float, float* %16
%1511 = load float*, float** %6
%1512 = load i32, i32* %10
%1513 = add nsw i32 %1512, 1
%1514 = sext i32 %1513 to i64
%1515 = getelementptr inbounds float, float* %1511, i64 %1514
store float %1510, float* %1515
%1516 = load i32, i32* %13
%1517 = load i32, i32* %8
%1518 = sub nsw i32 %1517, %1516
store i32 %1518, i32* %8
%1519 = load i32, i32* %10
%1520 = sub nsw i32 %1519, 2
store i32 %1520, i32* %10
%1521 = load float*, float** %6
%1522 = load i32, i32* %8
%1523 = sext i32 %1522 to i64
%1524 = getelementptr inbounds float, float* %1521, i64 %1523
%1525 = load float, float* %1524
store float %1525, float* %15
%1526 = load float*, float** %6
%1527 = load i32, i32* %8
%1528 = add nsw i32 %1527, 1
%1529 = sext i32 %1528 to i64
%1530 = getelementptr inbounds float, float* %1526, i64 %1529
%1531 = load float, float* %1530
store float %1531, float* %16
%1532 = load float*, float** %6
%1533 = load i32, i32* %10
%1534 = sext i32 %1533 to i64
%1535 = getelementptr inbounds float, float* %1532, i64 %1534
%1536 = load float, float* %1535
store float %1536, float* %17
%1537 = load float*, float** %6
%1538 = load i32, i32* %10
%1539 = add nsw i32 %1538, 1
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds float, float* %1537, i64 %1540
%1542 = load float, float* %1541
store float %1542, float* %18
%1543 = load float, float* %17
%1544 = load float*, float** %6
%1545 = load i32, i32* %8
%1546 = sext i32 %1545 to i64
%1547 = getelementptr inbounds float, float* %1544, i64 %1546
store float %1543, float* %1547
%1548 = load float, float* %18
%1549 = load float*, float** %6
%1550 = load i32, i32* %8
%1551 = add nsw i32 %1550, 1
%1552 = sext i32 %1551 to i64
%1553 = getelementptr inbounds float, float* %1549, i64 %1552
store float %1548, float* %1553
%1554 = load float, float* %15
%1555 = load float*, float** %6
%1556 = load i32, i32* %10
%1557 = sext i32 %1556 to i64
%1558 = getelementptr inbounds float, float* %1555, i64 %1557
store float %1554, float* %1558
%1559 = load float, float* %16
%1560 = load float*, float** %6
%1561 = load i32, i32* %10
%1562 = add nsw i32 %1561, 1
%1563 = sext i32 %1562 to i64
%1564 = getelementptr inbounds float, float* %1560, i64 %1563
store float %1559, float* %1564
%1565 = load i32, i32* %14
%1566 = load i32, i32* %8
%1567 = sub nsw i32 %1566, %1565
store i32 %1567, i32* %8
%1568 = load i32, i32* %14
%1569 = load i32, i32* %10
%1570 = sub nsw i32 %1569, %1568
store i32 %1570, i32* %10
%1571 = load float*, float** %6
%1572 = load i32, i32* %8
%1573 = sext i32 %1572 to i64
%1574 = getelementptr inbounds float, float* %1571, i64 %1573
%1575 = load float, float* %1574
store float %1575, float* %15
%1576 = load float*, float** %6
%1577 = load i32, i32* %8
%1578 = add nsw i32 %1577, 1
%1579 = sext i32 %1578 to i64
%1580 = getelementptr inbounds float, float* %1576, i64 %1579
%1581 = load float, float* %1580
store float %1581, float* %16
%1582 = load float*, float** %6
%1583 = load i32, i32* %10
%1584 = sext i32 %1583 to i64
%1585 = getelementptr inbounds float, float* %1582, i64 %1584
%1586 = load float, float* %1585
store float %1586, float* %17
%1587 = load float*, float** %6
%1588 = load i32, i32* %10
%1589 = add nsw i32 %1588, 1
%1590 = sext i32 %1589 to i64
%1591 = getelementptr inbounds float, float* %1587, i64 %1590
%1592 = load float, float* %1591
store float %1592, float* %18
%1593 = load float, float* %17
%1594 = load float*, float** %6
%1595 = load i32, i32* %8
%1596 = sext i32 %1595 to i64
%1597 = getelementptr inbounds float, float* %1594, i64 %1596
store float %1593, float* %1597
%1598 = load float, float* %18
%1599 = load float*, float** %6
%1600 = load i32, i32* %8
%1601 = add nsw i32 %1600, 1
%1602 = sext i32 %1601 to i64
%1603 = getelementptr inbounds float, float* %1599, i64 %1602
store float %1598, float* %1603
%1604 = load float, float* %15
%1605 = load float*, float** %6
%1606 = load i32, i32* %10
%1607 = sext i32 %1606 to i64
%1608 = getelementptr inbounds float, float* %1605, i64 %1607
store float %1604, float* %1608
%1609 = load float, float* %16
%1610 = load float*, float** %6
%1611 = load i32, i32* %10
%1612 = add nsw i32 %1611, 1
%1613 = sext i32 %1612 to i64
%1614 = getelementptr inbounds float, float* %1610, i64 %1613
store float %1609, float* %1614
br label %1615
1615: ; preds = %1203
%1616 = load i32, i32* %7
%1617 = add nsw i32 %1616, 1
store i32 %1617, i32* %7
br label %1199
1618: ; preds = %1199
%1619 = load i32, i32* %9
%1620 = mul nsw i32 4, %1619
%1621 = load i32*, i32** %5
%1622 = load i32, i32* %12
%1623 = load i32, i32* %9
%1624 = add nsw i32 %1622, %1623
%1625 = sext i32 %1624 to i64
%1626 = getelementptr inbounds i32, i32* %1621, i64 %1625
%1627 = load i32, i32* %1626
%1628 = add nsw i32 %1620, %1627
store i32 %1628, i32* %10
%1629 = load i32, i32* %10
%1630 = add nsw i32 %1629, 2
store i32 %1630, i32* %8
%1631 = load i32, i32* %13
%1632 = load i32, i32* %10
%1633 = add nsw i32 %1632, %1631
store i32 %1633, i32* %10
%1634 = load float*, float** %6
%1635 = load i32, i32* %8
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds float, float* %1634, i64 %1636
%1638 = load float, float* %1637
store float %1638, float* %15
%1639 = load float*, float** %6
%1640 = load i32, i32* %8
%1641 = add nsw i32 %1640, 1
%1642 = sext i32 %1641 to i64
%1643 = getelementptr inbounds float, float* %1639, i64 %1642
%1644 = load float, float* %1643
store float %1644, float* %16
%1645 = load float*, float** %6
%1646 = load i32, i32* %10
%1647 = sext i32 %1646 to i64
%1648 = getelementptr inbounds float, float* %1645, i64 %1647
%1649 = load float, float* %1648
store float %1649, float* %17
%1650 = load float*, float** %6
%1651 = load i32, i32* %10
%1652 = add nsw i32 %1651, 1
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds float, float* %1650, i64 %1653
%1655 = load float, float* %1654
store float %1655, float* %18
%1656 = load float, float* %17
%1657 = load float*, float** %6
%1658 = load i32, i32* %8
%1659 = sext i32 %1658 to i64
%1660 = getelementptr inbounds float, float* %1657, i64 %1659
store float %1656, float* %1660
%1661 = load float, float* %18
%1662 = load float*, float** %6
%1663 = load i32, i32* %8
%1664 = add nsw i32 %1663, 1
%1665 = sext i32 %1664 to i64
%1666 = getelementptr inbounds float, float* %1662, i64 %1665
store float %1661, float* %1666
%1667 = load float, float* %15
%1668 = load float*, float** %6
%1669 = load i32, i32* %10
%1670 = sext i32 %1669 to i64
%1671 = getelementptr inbounds float, float* %1668, i64 %1670
store float %1667, float* %1671
%1672 = load float, float* %16
%1673 = load float*, float** %6
%1674 = load i32, i32* %10
%1675 = add nsw i32 %1674, 1
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds float, float* %1673, i64 %1676
store float %1672, float* %1677
%1678 = load i32, i32* %14
%1679 = load i32, i32* %8
%1680 = add nsw i32 %1679, %1678
store i32 %1680, i32* %8
%1681 = load i32, i32* %14
%1682 = load i32, i32* %10
%1683 = add nsw i32 %1682, %1681
store i32 %1683, i32* %10
%1684 = load float*, float** %6
%1685 = load i32, i32* %8
%1686 = sext i32 %1685 to i64
%1687 = getelementptr inbounds float, float* %1684, i64 %1686
%1688 = load float, float* %1687
store float %1688, float* %15
%1689 = load float*, float** %6
%1690 = load i32, i32* %8
%1691 = add nsw i32 %1690, 1
%1692 = sext i32 %1691 to i64
%1693 = getelementptr inbounds float, float* %1689, i64 %1692
%1694 = load float, float* %1693
store float %1694, float* %16
%1695 = load float*, float** %6
%1696 = load i32, i32* %10
%1697 = sext i32 %1696 to i64
%1698 = getelementptr inbounds float, float* %1695, i64 %1697
%1699 = load float, float* %1698
store float %1699, float* %17
%1700 = load float*, float** %6
%1701 = load i32, i32* %10
%1702 = add nsw i32 %1701, 1
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds float, float* %1700, i64 %1703
%1705 = load float, float* %1704
store float %1705, float* %18
%1706 = load float, float* %17
%1707 = load float*, float** %6
%1708 = load i32, i32* %8
%1709 = sext i32 %1708 to i64
%1710 = getelementptr inbounds float, float* %1707, i64 %1709
store float %1706, float* %1710
%1711 = load float, float* %18
%1712 = load float*, float** %6
%1713 = load i32, i32* %8
%1714 = add nsw i32 %1713, 1
%1715 = sext i32 %1714 to i64
%1716 = getelementptr inbounds float, float* %1712, i64 %1715
store float %1711, float* %1716
%1717 = load float, float* %15
%1718 = load float*, float** %6
%1719 = load i32, i32* %10
%1720 = sext i32 %1719 to i64
%1721 = getelementptr inbounds float, float* %1718, i64 %1720
store float %1717, float* %1721
%1722 = load float, float* %16
%1723 = load float*, float** %6
%1724 = load i32, i32* %10
%1725 = add nsw i32 %1724, 1
%1726 = sext i32 %1725 to i64
%1727 = getelementptr inbounds float, float* %1723, i64 %1726
store float %1722, float* %1727
br label %1728
1728: ; preds = %1618
%1729 = load i32, i32* %9
%1730 = add nsw i32 %1729, 1
store i32 %1730, i32* %9
br label %1194
1731: ; preds = %1194
br label %1732
1732: ; preds = %1731, %1192
ret void
}

LLVM IR (-O2):
define void @bitrv2(i32 %0, i32* nocapture %1, float* %2) {
br label %4
4: ; preds = %4, %3
%5 = phi i32 [ %0, %3 ], [ %7, %4 ]
%6 = phi i32 [ 1, %3 ], [ %9, %4 ]
%7 = ashr i32 %5, 2
%8 = icmp sgt i32 %5, 35
%9 = shl i32 %6, 1
br i1 %8, label %4, label %10
10: ; preds = %4
%11 = ashr i32 %0, 1
%12 = shl nsw i32 %6, 2
%13 = icmp eq i32 %7, 8
%14 = icmp sgt i32 %6, 0
br i1 %13, label %21, label %15
15: ; preds = %10
br i1 %14, label %16, label %577
16: ; preds = %15
%17 = sext i32 %12 to i64
%18 = sext i32 %11 to i64
%19 = zext i32 %6 to i64
%20 = zext i32 %6 to i64
br label %400
21: ; preds = %10
br i1 %14, label %22, label %577
22: ; preds = %21
%23 = shl nsw i32 %6, 3
%24 = sext i32 %12 to i64
%25 = sext i32 %11 to i64
%26 = zext i32 %6 to i64
%27 = zext i32 %6 to i64
br label %28
28: ; preds = %22, %296
%29 = phi i64 [ 0, %22 ], [ %398, %296 ]
%30 = icmp eq i64 %29, 0
%31 = add nuw nsw i64 %29, %26
br i1 %30, label %296, label %32
32: ; preds = %28
%33 = getelementptr inbounds i32, i32* %1, i64 %31
%34 = load i32, i32* %33
%35 = shl nsw i32 %34, 1
%36 = trunc i64 %29 to i32
%37 = shl nsw i32 %36, 2
%38 = sext i32 %35 to i64
br label %39
39: ; preds = %32, %39
%40 = phi i64 [ 0, %32 ], [ %294, %39 ]
%41 = shl nsw i64 %40, 2
%42 = add nsw i64 %41, %38
%43 = add nuw nsw i64 %40, %26
%44 = getelementptr inbounds i32, i32* %1, i64 %43
%45 = load i32, i32* %44
%46 = shl nsw i32 %45, 1
%47 = add nsw i32 %46, %37
%48 = getelementptr inbounds float, float* %2, i64 %42
%49 = load float, float* %48
%50 = or i64 %42, 1
%51 = getelementptr inbounds float, float* %2, i64 %50
%52 = load float, float* %51
%53 = sext i32 %47 to i64
%54 = getelementptr inbounds float, float* %2, i64 %53
%55 = load float, float* %54
%56 = or i32 %47, 1
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %2, i64 %57
%59 = load float, float* %58
store float %55, float* %48
store float %59, float* %51
store float %49, float* %54
store float %52, float* %58
%60 = add nsw i64 %42, %24
%61 = add nsw i32 %47, %23
%62 = getelementptr inbounds float, float* %2, i64 %60
%63 = load float, float* %62
%64 = or i64 %60, 1
%65 = getelementptr inbounds float, float* %2, i64 %64
%66 = load float, float* %65
%67 = sext i32 %61 to i64
%68 = getelementptr inbounds float, float* %2, i64 %67
%69 = load float, float* %68
%70 = or i32 %61, 1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds float, float* %2, i64 %71
%73 = load float, float* %72
store float %69, float* %62
store float %73, float* %65
store float %63, float* %68
store float %66, float* %72
%74 = add nsw i64 %60, %24
%75 = sub nsw i32 %61, %12
%76 = getelementptr inbounds float, float* %2, i64 %74
%77 = load float, float* %76
%78 = shl i64 %74, 32
%79 = ashr exact i64 %78, 32
%80 = or i64 %79, 1
%81 = getelementptr inbounds float, float* %2, i64 %80
%82 = load float, float* %81
%83 = sext i32 %75 to i64
%84 = getelementptr inbounds float, float* %2, i64 %83
%85 = load float, float* %84
%86 = or i32 %75, 1
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %2, i64 %87
%89 = load float, float* %88
store float %85, float* %76
store float %89, float* %81
store float %77, float* %84
store float %82, float* %88
%90 = add nsw i64 %74, %24
%91 = add nsw i32 %75, %23
%92 = getelementptr inbounds float, float* %2, i64 %90
%93 = load float, float* %92
%94 = shl i64 %90, 32
%95 = ashr exact i64 %94, 32
%96 = or i64 %95, 1
%97 = getelementptr inbounds float, float* %2, i64 %96
%98 = load float, float* %97
%99 = sext i32 %91 to i64
%100 = getelementptr inbounds float, float* %2, i64 %99
%101 = load float, float* %100
%102 = or i32 %91, 1
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds float, float* %2, i64 %103
%105 = load float, float* %104
store float %101, float* %92
store float %105, float* %97
store float %93, float* %100
store float %98, float* %104
%106 = add nsw i64 %90, %25
%107 = add nsw i32 %91, 2
%108 = getelementptr inbounds float, float* %2, i64 %106
%109 = load float, float* %108
%110 = add nsw i64 %106, 1
%111 = getelementptr inbounds float, float* %2, i64 %110
%112 = load float, float* %111
%113 = sext i32 %107 to i64
%114 = getelementptr inbounds float, float* %2, i64 %113
%115 = load float, float* %114
%116 = add nsw i32 %91, 3
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %2, i64 %117
%119 = load float, float* %118
store float %115, float* %108
store float %119, float* %111
store float %109, float* %114
store float %112, float* %118
%120 = sub nsw i64 %106, %24
%121 = sub nsw i32 %107, %23
%122 = getelementptr inbounds float, float* %2, i64 %120
%123 = load float, float* %122
%124 = add nsw i64 %120, 1
%125 = getelementptr inbounds float, float* %2, i64 %124
%126 = load float, float* %125
%127 = sext i32 %121 to i64
%128 = getelementptr inbounds float, float* %2, i64 %127
%129 = load float, float* %128
%130 = add nsw i32 %121, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %2, i64 %131
%133 = load float, float* %132
store float %129, float* %122
store float %133, float* %125
store float %123, float* %128
store float %126, float* %132
%134 = sub nsw i64 %120, %24
%135 = add nsw i32 %121, %12
%136 = getelementptr inbounds float, float* %2, i64 %134
%137 = load float, float* %136
%138 = add nsw i64 %134, 1
%139 = getelementptr inbounds float, float* %2, i64 %138
%140 = load float, float* %139
%141 = sext i32 %135 to i64
%142 = getelementptr inbounds float, float* %2, i64 %141
%143 = load float, float* %142
%144 = add nsw i32 %135, 1
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %2, i64 %145
%147 = load float, float* %146
store float %143, float* %136
store float %147, float* %139
store float %137, float* %142
store float %140, float* %146
%148 = sub nsw i64 %134, %24
%149 = sub nsw i32 %135, %23
%150 = getelementptr inbounds float, float* %2, i64 %148
%151 = load float, float* %150
%152 = add nsw i64 %148, 1
%153 = getelementptr inbounds float, float* %2, i64 %152
%154 = load float, float* %153
%155 = sext i32 %149 to i64
%156 = getelementptr inbounds float, float* %2, i64 %155
%157 = load float, float* %156
%158 = add nsw i32 %149, 1
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %2, i64 %159
%161 = load float, float* %160
store float %157, float* %150
store float %161, float* %153
store float %151, float* %156
store float %154, float* %160
%162 = add nsw i64 %148, 2
%163 = add nsw i32 %149, %11
%164 = getelementptr inbounds float, float* %2, i64 %162
%165 = load float, float* %164
%166 = add nsw i64 %148, 3
%167 = getelementptr inbounds float, float* %2, i64 %166
%168 = load float, float* %167
%169 = sext i32 %163 to i64
%170 = getelementptr inbounds float, float* %2, i64 %169
%171 = load float, float* %170
%172 = add nsw i32 %163, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %2, i64 %173
%175 = load float, float* %174
store float %171, float* %164
store float %175, float* %167
store float %165, float* %170
store float %168, float* %174
%176 = add i32 %135, %11
%177 = shl i64 %134, 32
%178 = add i64 %177, 8589934592
%179 = ashr exact i64 %178, 32
%180 = getelementptr inbounds float, float* %2, i64 %179
%181 = load float, float* %180
%182 = shl i64 %134, 32
%183 = add i64 %182, 12884901888
%184 = ashr exact i64 %183, 32
%185 = getelementptr inbounds float, float* %2, i64 %184
%186 = load float, float* %185
%187 = sext i32 %176 to i64
%188 = getelementptr inbounds float, float* %2, i64 %187
%189 = load float, float* %188
%190 = add nsw i32 %176, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %2, i64 %191
%193 = load float, float* %192
store float %189, float* %180
store float %193, float* %185
store float %181, float* %188
store float %186, float* %192
%194 = sub nsw i32 %176, %12
%195 = shl i64 %120, 32
%196 = add i64 %195, 8589934592
%197 = ashr exact i64 %196, 32
%198 = getelementptr inbounds float, float* %2, i64 %197
%199 = load float, float* %198
%200 = shl i64 %120, 32
%201 = add i64 %200, 12884901888
%202 = ashr exact i64 %201, 32
%203 = getelementptr inbounds float, float* %2, i64 %202
%204 = load float, float* %203
%205 = sext i32 %194 to i64
%206 = getelementptr inbounds float, float* %2, i64 %205
%207 = load float, float* %206
%208 = add nsw i32 %194, 1
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %2, i64 %209
%211 = load float, float* %210
store float %207, float* %198
store float %211, float* %203
store float %199, float* %206
store float %204, float* %210
%212 = trunc i64 %106 to i32
%213 = add i32 %212, 2
%214 = add nsw i32 %194, %23
%215 = sext i32 %213 to i64
%216 = getelementptr inbounds float, float* %2, i64 %215
%217 = load float, float* %216
%218 = shl i64 %106, 32
%219 = add i64 %218, 12884901888
%220 = ashr exact i64 %219, 32
%221 = getelementptr inbounds float, float* %2, i64 %220
%222 = load float, float* %221
%223 = sext i32 %214 to i64
%224 = getelementptr inbounds float, float* %2, i64 %223
%225 = load float, float* %224
%226 = add nsw i32 %214, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %2, i64 %227
%229 = load float, float* %228
store float %225, float* %216
store float %229, float* %221
store float %217, float* %224
store float %222, float* %228
%230 = sub nsw i32 %213, %11
%231 = add nsw i32 %214, -2
%232 = sext i32 %230 to i64
%233 = getelementptr inbounds float, float* %2, i64 %232
%234 = load float, float* %233
%235 = add nsw i32 %230, 1
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %2, i64 %236
%238 = load float, float* %237
%239 = sext i32 %231 to i64
%240 = getelementptr inbounds float, float* %2, i64 %239
%241 = load float, float* %240
%242 = add nsw i32 %214, -1
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds float, float* %2, i64 %243
%245 = load float, float* %244
store float %241, float* %233
store float %245, float* %237
store float %234, float* %240
store float %238, float* %244
%246 = sub nsw i32 %230, %12
%247 = sub nsw i32 %231, %23
%248 = sext i32 %246 to i64
%249 = getelementptr inbounds float, float* %2, i64 %248
%250 = load float, float* %249
%251 = add nsw i32 %246, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %2, i64 %252
%254 = load float, float* %253
%255 = sext i32 %247 to i64
%256 = getelementptr inbounds float, float* %2, i64 %255
%257 = load float, float* %256
%258 = add nsw i32 %247, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float, float* %2, i64 %259
%261 = load float, float* %260
store float %257, float* %249
store float %261, float* %253
store float %250, float* %256
store float %254, float* %260
%262 = sub nsw i32 %246, %12
%263 = add nsw i32 %247, %12
%264 = sext i32 %262 to i64
%265 = getelementptr inbounds float, float* %2, i64 %264
%266 = load float, float* %265
%267 = add nsw i32 %262, 1
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float, float* %2, i64 %268
%270 = load float, float* %269
%271 = sext i32 %263 to i64
%272 = getelementptr inbounds float, float* %2, i64 %271
%273 = load float, float* %272
%274 = add nsw i32 %263, 1
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %2, i64 %275
%277 = load float, float* %276
store float %273, float* %265
store float %277, float* %269
store float %266, float* %272
store float %270, float* %276
%278 = sub nsw i32 %262, %12
%279 = sub nsw i32 %263, %23
%280 = sext i32 %278 to i64
%281 = getelementptr inbounds float, float* %2, i64 %280
%282 = load float, float* %281
%283 = add nsw i32 %278, 1
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %2, i64 %284
%286 = load float, float* %285
%287 = sext i32 %279 to i64
%288 = getelementptr inbounds float, float* %2, i64 %287
%289 = load float, float* %288
%290 = add nsw i32 %279, 1
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds float, float* %2, i64 %291
%293 = load float, float* %292
store float %289, float* %281
store float %293, float* %285
store float %282, float* %288
store float %286, float* %292
%294 = add nuw nsw i64 %40, 1
%295 = icmp eq i64 %294, %29
br i1 %295, label %296, label %39
296: ; preds = %39, %28
%297 = phi i32 [ 0, %28 ], [ %37, %39 ]
%298 = getelementptr inbounds i32, i32* %1, i64 %31
%299 = load i32, i32* %298
%300 = shl nsw i32 %299, 1
%301 = add nsw i32 %300, %297
%302 = add nsw i32 %301, 2
%303 = add nsw i32 %301, %11
%304 = sext i32 %302 to i64
%305 = getelementptr inbounds float, float* %2, i64 %304
%306 = load float, float* %305
%307 = add nsw i32 %301, 3
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %2, i64 %308
%310 = load float, float* %309
%311 = sext i32 %303 to i64
%312 = getelementptr inbounds float, float* %2, i64 %311
%313 = load float, float* %312
%314 = add nsw i32 %303, 1
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds float, float* %2, i64 %315
%317 = load float, float* %316
store float %313, float* %305
store float %317, float* %309
store float %306, float* %312
store float %310, float* %316
%318 = add nsw i32 %302, %12
%319 = add nsw i32 %303, %23
%320 = sext i32 %318 to i64
%321 = getelementptr inbounds float, float* %2, i64 %320
%322 = load float, float* %321
%323 = or i32 %318, 1
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %2, i64 %324
%326 = load float, float* %325
%327 = sext i32 %319 to i64
%328 = getelementptr inbounds float, float* %2, i64 %327
%329 = load float, float* %328
%330 = add nsw i32 %319, 1
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %2, i64 %331
%333 = load float, float* %332
store float %329, float* %321
store float %333, float* %325
store float %322, float* %328
store float %326, float* %332
%334 = add nsw i32 %318, %12
%335 = sub nsw i32 %319, %12
%336 = sext i32 %334 to i64
%337 = getelementptr inbounds float, float* %2, i64 %336
%338 = load float, float* %337
%339 = or i32 %334, 1
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float, float* %2, i64 %340
%342 = load float, float* %341
%343 = sext i32 %335 to i64
%344 = getelementptr inbounds float, float* %2, i64 %343
%345 = load float, float* %344
%346 = add nsw i32 %335, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %2, i64 %347
%349 = load float, float* %348
store float %345, float* %337
store float %349, float* %341
store float %338, float* %344
store float %342, float* %348
%350 = add nsw i32 %334, -2
%351 = sub nsw i32 %335, %11
%352 = sext i32 %350 to i64
%353 = getelementptr inbounds float, float* %2, i64 %352
%354 = load float, float* %353
%355 = add nsw i32 %334, -1
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float, float* %2, i64 %356
%358 = load float, float* %357
%359 = sext i32 %351 to i64
%360 = getelementptr inbounds float, float* %2, i64 %359
%361 = load float, float* %360
%362 = add nsw i32 %351, 1
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float, float* %2, i64 %363
%365 = load float, float* %364
store float %361, float* %353
store float %365, float* %357
store float %354, float* %360
store float %358, float* %364
%366 = add i32 %334, %11
%367 = add i32 %335, 2
%368 = sext i32 %366 to i64
%369 = getelementptr inbounds float, float* %2, i64 %368
%370 = load float, float* %369
%371 = add nsw i32 %366, 1
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %2, i64 %372
%374 = load float, float* %373
%375 = sext i32 %367 to i64
%376 = getelementptr inbounds float, float* %2, i64 %375
%377 = load float, float* %376
%378 = add i32 %335, 3
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %2, i64 %379
%381 = load float, float* %380
store float %377, float* %369
store float %381, float* %373
store float %370, float* %376
store float %374, float* %380
%382 = add i32 %334, %12
%383 = add i32 %335, %23
%384 = sext i32 %382 to i64
%385 = getelementptr inbounds float, float* %2, i64 %384
%386 = load float, float* %385
%387 = or i32 %382, 1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %2, i64 %388
%390 = load float, float* %389
%391 = sext i32 %383 to i64
%392 = getelementptr inbounds float, float* %2, i64 %391
%393 = load float, float* %392
%394 = add nsw i32 %383, 1
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds float, float* %2, i64 %395
%397 = load float, float* %396
store float %393, float* %385
store float %397, float* %389
store float %386, float* %392
store float %390, float* %396
%398 = add nuw nsw i64 %29, 1
%399 = icmp eq i64 %398, %27
br i1 %399, label %577, label %28
400: ; preds = %16, %538
%401 = phi i64 [ 0, %16 ], [ %575, %538 ]
%402 = icmp eq i64 %401, 0
%403 = add nuw nsw i64 %401, %19
br i1 %402, label %538, label %404
404: ; preds = %400
%405 = getelementptr inbounds i32, i32* %1, i64 %403
%406 = load i32, i32* %405
%407 = trunc i64 %401 to i32
%408 = shl nsw i32 %407, 2
%409 = sext i32 %406 to i64
br label %410
410: ; preds = %404, %410
%411 = phi i64 [ 0, %404 ], [ %536, %410 ]
%412 = shl nsw i64 %411, 2
%413 = add nsw i64 %412, %409
%414 = add nuw nsw i64 %411, %19
%415 = getelementptr inbounds i32, i32* %1, i64 %414
%416 = load i32, i32* %415
%417 = add nsw i32 %416, %408
%418 = getelementptr inbounds float, float* %2, i64 %413
%419 = load float, float* %418
%420 = add nsw i64 %413, 1
%421 = getelementptr inbounds float, float* %2, i64 %420
%422 = load float, float* %421
%423 = sext i32 %417 to i64
%424 = getelementptr inbounds float, float* %2, i64 %423
%425 = load float, float* %424
%426 = add nsw i32 %417, 1
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds float, float* %2, i64 %427
%429 = load float, float* %428
store float %425, float* %418
store float %429, float* %421
store float %419, float* %424
store float %422, float* %428
%430 = add nsw i64 %413, %17
%431 = add nsw i32 %417, %12
%432 = getelementptr inbounds float, float* %2, i64 %430
%433 = load float, float* %432
%434 = add nsw i64 %430, 1
%435 = getelementptr inbounds float, float* %2, i64 %434
%436 = load float, float* %435
%437 = sext i32 %431 to i64
%438 = getelementptr inbounds float, float* %2, i64 %437
%439 = load float, float* %438
%440 = add nsw i32 %431, 1
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds float, float* %2, i64 %441
%443 = load float, float* %442
store float %439, float* %432
store float %443, float* %435
store float %433, float* %438
store float %436, float* %442
%444 = add nsw i64 %430, %18
%445 = add nsw i32 %431, 2
%446 = getelementptr inbounds float, float* %2, i64 %444
%447 = load float, float* %446
%448 = add nsw i64 %444, 1
%449 = getelementptr inbounds float, float* %2, i64 %448
%450 = load float, float* %449
%451 = sext i32 %445 to i64
%452 = getelementptr inbounds float, float* %2, i64 %451
%453 = load float, float* %452
%454 = add nsw i32 %431, 3
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds float, float* %2, i64 %455
%457 = load float, float* %456
store float %453, float* %446
store float %457, float* %449
store float %447, float* %452
store float %450, float* %456
%458 = sub nsw i64 %444, %17
%459 = sub nsw i32 %445, %12
%460 = getelementptr inbounds float, float* %2, i64 %458
%461 = load float, float* %460
%462 = add nsw i64 %458, 1
%463 = getelementptr inbounds float, float* %2, i64 %462
%464 = load float, float* %463
%465 = sext i32 %459 to i64
%466 = getelementptr inbounds float, float* %2, i64 %465
%467 = load float, float* %466
%468 = add nsw i32 %459, 1
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds float, float* %2, i64 %469
%471 = load float, float* %470
store float %467, float* %460
store float %471, float* %463
store float %461, float* %466
store float %464, float* %470
%472 = add nsw i64 %458, 2
%473 = add nsw i32 %459, %11
%474 = getelementptr inbounds float, float* %2, i64 %472
%475 = load float, float* %474
%476 = add nsw i64 %458, 3
%477 = getelementptr inbounds float, float* %2, i64 %476
%478 = load float, float* %477
%479 = sext i32 %473 to i64
%480 = getelementptr inbounds float, float* %2, i64 %479
%481 = load float, float* %480
%482 = add nsw i32 %473, 1
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds float, float* %2, i64 %483
%485 = load float, float* %484
store float %481, float* %474
store float %485, float* %477
store float %475, float* %480
store float %478, float* %484
%486 = trunc i64 %444 to i32
%487 = add i32 %486, 2
%488 = add i32 %445, %11
%489 = sext i32 %487 to i64
%490 = getelementptr inbounds float, float* %2, i64 %489
%491 = load float, float* %490
%492 = shl i64 %444, 32
%493 = add i64 %492, 12884901888
%494 = ashr exact i64 %493, 32
%495 = getelementptr inbounds float, float* %2, i64 %494
%496 = load float, float* %495
%497 = sext i32 %488 to i64
%498 = getelementptr inbounds float, float* %2, i64 %497
%499 = load float, float* %498
%500 = add nsw i32 %488, 1
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds float, float* %2, i64 %501
%503 = load float, float* %502
store float %499, float* %490
store float %503, float* %495
store float %491, float* %498
store float %496, float* %502
%504 = sub nsw i32 %487, %11
%505 = add i32 %431, %11
%506 = sext i32 %504 to i64
%507 = getelementptr inbounds float, float* %2, i64 %506
%508 = load float, float* %507
%509 = add nsw i32 %504, 1
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds float, float* %2, i64 %510
%512 = load float, float* %511
%513 = sext i32 %505 to i64
%514 = getelementptr inbounds float, float* %2, i64 %513
%515 = load float, float* %514
%516 = add nsw i32 %505, 1
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds float, float* %2, i64 %517
%519 = load float, float* %518
store float %515, float* %507
store float %519, float* %511
store float %508, float* %514
store float %512, float* %518
%520 = sub nsw i32 %504, %12
%521 = sub nsw i32 %505, %12
%522 = sext i32 %520 to i64
%523 = getelementptr inbounds float, float* %2, i64 %522
%524 = load float, float* %523
%525 = add nsw i32 %520, 1
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds float, float* %2, i64 %526
%528 = load float, float* %527
%529 = sext i32 %521 to i64
%530 = getelementptr inbounds float, float* %2, i64 %529
%531 = load float, float* %530
%532 = add nsw i32 %521, 1
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float, float* %2, i64 %533
%535 = load float, float* %534
store float %531, float* %523
store float %535, float* %527
store float %524, float* %530
store float %528, float* %534
%536 = add nuw nsw i64 %411, 1
%537 = icmp eq i64 %536, %401
br i1 %537, label %538, label %410
538: ; preds = %410, %400
%539 = phi i32 [ 0, %400 ], [ %408, %410 ]
%540 = getelementptr inbounds i32, i32* %1, i64 %403
%541 = load i32, i32* %540
%542 = add nsw i32 %541, %539
%543 = add nsw i32 %542, 2
%544 = add nsw i32 %542, %11
%545 = sext i32 %543 to i64
%546 = getelementptr inbounds float, float* %2, i64 %545
%547 = load float, float* %546
%548 = add nsw i32 %542, 3
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds float, float* %2, i64 %549
%551 = load float, float* %550
%552 = sext i32 %544 to i64
%553 = getelementptr inbounds float, float* %2, i64 %552
%554 = load float, float* %553
%555 = add nsw i32 %544, 1
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds float, float* %2, i64 %556
%558 = load float, float* %557
store float %554, float* %546
store float %558, float* %550
store float %547, float* %553
store float %551, float* %557
%559 = add nsw i32 %543, %12
%560 = add nsw i32 %544, %12
%561 = sext i32 %559 to i64
%562 = getelementptr inbounds float, float* %2, i64 %561
%563 = load float, float* %562
%564 = add nsw i32 %559, 1
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %2, i64 %565
%567 = load float, float* %566
%568 = sext i32 %560 to i64
%569 = getelementptr inbounds float, float* %2, i64 %568
%570 = load float, float* %569
%571 = add nsw i32 %560, 1
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds float, float* %2, i64 %572
%574 = load float, float* %573
store float %570, float* %562
store float %574, float* %566
store float %563, float* %569
store float %567, float* %573
%575 = add nuw nsw i64 %401, 1
%576 = icmp eq i64 %575, %20
br i1 %576, label %577, label %400
577: ; preds = %538, %296, %15, %21
ret void
}