void bitrv2(int n, float *a) {
  int j0, k0, j1, k1, l, m, i, j, k, nh;
  float xr, xi, yr, yi;
  m = 4;
  for (l = n >> 2; l > 8; l >>= 2) {
    m <<= 1;
  }
  nh = n >> 1;
  if (l == 8) {
    j0 = 0;
    for (k0 = 0; k0 < m; k0 += 4) {
      k = k0;
      for (j = j0; j < j0 + k0; j += 4) {
        xr = a[j];
        xi = a[j + 1];
        yr = a[k];
        yi = a[k + 1];
        a[j] = yr;
        a[j + 1] = yi;
        a[k] = xr;
        a[k + 1] = xi;
        j1 = j + m;
        k1 = k + 2 * m;
        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 += m;
        k1 -= m;
        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 += m;
        k1 += 2 * m;
        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 -= m;
        k1 -= 2 * m;
        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 -= m;
        k1 += m;
        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 -= m;
        k1 -= 2 * m;
        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 += m;
        k1 += 2 * m;
        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 += m;
        k1 -= m;
        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 += m;
        k1 += 2 * m;
        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 -= m;
        k1 -= 2 * m;
        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 -= m;
        k1 += m;
        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 -= m;
        k1 -= 2 * m;
        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;
        for (i = nh >> 1; i > (k ^= i); i >>= 1)
          ;
      }
      k1 = j0 + k0;
      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 += m;
      k1 += 2 * m;
      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 += m;
      k1 -= m;
      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 - m;
      k1 += 2 * m - 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;
      for (i = nh >> 1; i > (j0 ^= i); i >>= 1)
        ;
    }
  } else {
    j0 = 0;
    for (k0 = 0; k0 < m; k0 += 4) {
      k = k0;
      for (j = j0; j < j0 + k0; j += 4) {
        xr = a[j];
        xi = a[j + 1];
        yr = a[k];
        yi = a[k + 1];
        a[j] = yr;
        a[j + 1] = yi;
        a[k] = xr;
        a[k + 1] = xi;
        j1 = j + m;
        k1 = k + m;
        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 -= m;
        k1 -= m;
        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 += m;
        k1 += m;
        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 -= m;
        k1 -= m;
        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;
        for (i = nh >> 1; i > (k ^= i); i >>= 1)
          ;
      }
      k1 = j0 + k0;
      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 += m;
      k1 += m;
      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;
      for (i = nh >> 1; i > (j0 ^= i); i >>= 1)
        ;
    }
  }
}


x86 assembly (clang, -O0):
<bitrv2>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x4,-0x28(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jle    113c <bitrv2+0x3c>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <bitrv2+0x1b>
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x8,-0x24(%rbp)
jne    21f8 <bitrv2+0x10f8>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    21f3 <bitrv2+0x10f3>
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1d4b <bitrv2+0xc4b>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
xor    -0x34(%rbp),%ecx
mov    %ecx,-0x34(%rbp)
cmp    %ecx,%eax
jle    1d38 <bitrv2+0xc38>
jmp    1d2a <bitrv2+0xc2a>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d11 <bitrv2+0xc11>
jmp    1d3d <bitrv2+0xc3d>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    1175 <bitrv2+0x75>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
sub    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
sub    $0x2,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
xor    -0x14(%rbp),%ecx
mov    %ecx,-0x14(%rbp)
cmp    %ecx,%eax
jle    21e0 <bitrv2+0x10e0>
jmp    21d2 <bitrv2+0x10d2>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    21b9 <bitrv2+0x10b9>
jmp    21e5 <bitrv2+0x10e5>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
jmp    115d <bitrv2+0x5d>
jmp    29d7 <bitrv2+0x18d7>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    29d2 <bitrv2+0x18d2>
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    281a <bitrv2+0x171a>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
xor    -0x34(%rbp),%ecx
mov    %ecx,-0x34(%rbp)
cmp    %ecx,%eax
jle    2807 <bitrv2+0x1707>
jmp    27f9 <bitrv2+0x16f9>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    27e0 <bitrv2+0x16e0>
jmp    280c <bitrv2+0x170c>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    221e <bitrv2+0x111e>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
xor    -0x14(%rbp),%ecx
mov    %ecx,-0x14(%rbp)
cmp    %ecx,%eax
jle    29bf <bitrv2+0x18bf>
jmp    29b1 <bitrv2+0x18b1>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2998 <bitrv2+0x1898>
jmp    29c4 <bitrv2+0x18c4>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
jmp    2206 <bitrv2+0x1106>
jmp    29d7 <bitrv2+0x18d7>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x4,%r13d
mov    %edi,-0x2c(%rsp)
mov    %edi,%eax
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%r12d
mov    %eax,%ecx
sar    $0x2,%eax
lea    (%r12,%r12,1),%r13d
cmp    $0x23,%ecx
jg     1120 <bitrv2+0x20>
mov    -0x2c(%rsp),%ecx
sar    %ecx
mov    %rcx,-0x28(%rsp)
cmp    $0x8,%eax
jne    15e2 <bitrv2+0x4e2>
test   %r12d,%r12d
jle    182d <bitrv2+0x72d>
sarl   $0x2,-0x2c(%rsp)
mov    %r12d,%eax
mov    %rax,-0x8(%rsp)
movslq -0x28(%rsp),%rax
mov    %rax,-0x10(%rsp)
xor    %r8d,%r8d
xor    %ecx,%ecx
mov    -0x28(%rsp),%r11
nop
lea    (%r8,%rcx,1),%eax
cltq
mov    %rax,-0x20(%rsp)
mov    %rcx,-0x18(%rsp)
test   %ecx,%ecx
je     14a9 <bitrv2+0x3a9>
movslq %r8d,%r15
mov    -0x18(%rsp),%rax
mov    %eax,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%r15,4),%rax
movslq %ebp,%rbx
movss  (%rsi,%rbx,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%r15,4)
movss  %xmm1,0x4(%rsi,%r15,4)
mov    %rax,(%rsi,%rbx,4)
mov    -0x8(%rsp),%rdi
lea    (%r15,%rdi,1),%rcx
add    %r13d,%ebx
mov    (%rsi,%rcx,4),%rax
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rax,(%rsi,%rbx,4)
add    %rdi,%rcx
sub    %r12d,%ebx
mov    (%rsi,%rcx,4),%rax
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rax,(%rsi,%rbx,4)
add    %rdi,%rcx
lea    (%rbx,%r13,1),%eax
mov    (%rsi,%rcx,4),%rdx
cltq
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rdx,(%rsi,%rax,4)
add    -0x10(%rsp),%rcx
mov    (%rsi,%rcx,4),%rdx
movss  0x8(%rsi,%rax,4),%xmm0
movss  0xc(%rsi,%rax,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rdx,0x8(%rsi,%rax,4)
mov    %rcx,%r14
sub    %rdi,%r14
lea    0x2(%rbx),%eax
mov    (%rsi,%r14,4),%rdx
cltq
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
movss  %xmm0,(%rsi,%r14,4)
movss  %xmm1,0x4(%rsi,%r14,4)
mov    %rdx,(%rsi,%rax,4)
mov    %r14,%rax
sub    %rdi,%rax
add    %r12d,%ebx
add    $0x2,%ebx
mov    (%rsi,%rax,4),%rdx
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm0
movss  0x4(%rsi,%rbx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rbx,4)
mov    %rax,%rdx
sub    %rdi,%rdx
mov    %ebx,%edi
sub    %r13d,%edi
mov    (%rsi,%rdx,4),%r9
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
movss  0x4(%rsi,%rdi,4),%xmm1
movss  %xmm0,(%rsi,%rdx,4)
movss  %xmm1,0x4(%rsi,%rdx,4)
mov    %r9,(%rsi,%rdi,4)
add    %r11d,%edi
mov    0x8(%rsi,%rdx,4),%r9
movslq %edi,%rdi
mov    (%rsi,%rdi,4),%r10
mov    %r10,0x8(%rsi,%rdx,4)
mov    %r9,(%rsi,%rdi,4)
add    %r11d,%ebx
shl    $0x20,%rax
movabs $0x200000000,%r9
lea    (%rax,%r9,1),%rdx
sar    $0x1e,%rdx
movss  (%rsi,%rdx,1),%xmm0
movabs $0x300000000,%r10
add    %r10,%rax
sar    $0x1e,%rax
movss  (%rsi,%rax,1),%xmm1
movslq %ebx,%rdi
movss  (%rsi,%rdi,4),%xmm2
movss  0x4(%rsi,%rdi,4),%xmm3
movss  %xmm2,(%rsi,%rdx,1)
movss  %xmm3,(%rsi,%rax,1)
movss  %xmm0,(%rsi,%rdi,4)
movss  %xmm1,0x4(%rsi,%rdi,4)
sub    %r12d,%edi
shl    $0x20,%r14
lea    (%r14,%r9,1),%rax
sar    $0x1e,%rax
movss  (%rsi,%rax,1),%xmm0
add    %r10,%r14
sar    $0x1e,%r14
movss  (%rsi,%r14,1),%xmm1
movslq %edi,%r9
movss  (%rsi,%r9,4),%xmm2
movss  0x4(%rsi,%r9,4),%xmm3
movss  %xmm2,(%rsi,%rax,1)
movss  %xmm3,(%rsi,%r14,1)
movss  %xmm0,(%rsi,%r9,4)
movss  %xmm1,0x4(%rsi,%r9,4)
lea    0x2(%rcx),%eax
lea    (%r9,%r13,1),%edx
cltq
movss  (%rsi,%rax,4),%xmm0
shl    $0x20,%rcx
add    %r10,%rcx
sar    $0x1e,%rcx
movss  (%rsi,%rcx,1),%xmm1
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm2
movss  0x4(%rsi,%rdx,4),%xmm3
movss  %xmm2,(%rsi,%rax,4)
movss  %xmm3,(%rsi,%rcx,1)
movss  %xmm0,(%rsi,%rdx,4)
movss  %xmm1,0x4(%rsi,%rdx,4)
sub    %r11d,%eax
cltq
mov    (%rsi,%rax,4),%rcx
movss  -0x8(%rsi,%rdx,4),%xmm0
movss  -0x4(%rsi,%rdx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rcx,-0x8(%rsi,%rdx,4)
sub    %r12d,%eax
lea    -0x2(%r9),%ecx
cltq
mov    (%rsi,%rax,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rcx,4)
sub    %r12d,%eax
lea    (%r9,%r12,1),%ecx
add    $0xfffffffe,%ecx
cltq
mov    (%rsi,%rax,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rcx,4)
sub    %r12d,%eax
sub    %r13d,%ecx
cltq
mov    (%rsi,%rax,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rcx,4)
mov    -0x2c(%rsp),%eax
mov    %eax,%ecx
nopl   0x0(%rax,%rax,1)
xor    %eax,%ebp
sar    %ecx
cmp    %ebp,%eax
mov    %ecx,%eax
jg     1490 <bitrv2+0x390>
add    $0x4,%r15
cmp    -0x20(%rsp),%r15
jl     11a0 <bitrv2+0xa0>
mov    -0x20(%rsp),%rdi
lea    (%rdi,%r12,1),%eax
mov    -0x28(%rsp),%rbx
lea    (%rdi,%rbx,1),%ecx
mov    0x8(%rsi,%rdi,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,0x8(%rsi,%rdi,4)
movss  %xmm1,0xc(%rsi,%rdi,4)
mov    %rdx,(%rsi,%rcx,4)
lea    (%rdi,%r12,1),%edx
add    $0x2,%edx
add    %r13d,%ecx
movslq %edx,%rdx
mov    (%rsi,%rdx,4),%rdi
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rdx,4)
movss  %xmm1,0x4(%rsi,%rdx,4)
mov    %rdi,(%rsi,%rcx,4)
add    %r12d,%eax
add    $0x2,%eax
sub    %r12d,%ecx
cltq
mov    (%rsi,%rax,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rcx,4)
mov    %ecx,%edx
sub    %ebx,%edx
mov    -0x8(%rsi,%rax,4),%rdi
movslq %edx,%rdx
mov    (%rsi,%rdx,4),%rbp
mov    %rbp,-0x8(%rsi,%rax,4)
mov    %rdi,(%rsi,%rdx,4)
lea    (%rax,%rbx,1),%edx
lea    0x2(%rcx),%edi
movslq %edx,%rdx
movss  (%rsi,%rdx,4),%xmm0
movss  0x4(%rsi,%rdx,4),%xmm1
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm2
lea    0x3(%rcx),%ebp
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm3
movss  %xmm2,(%rsi,%rdx,4)
movss  %xmm3,0x4(%rsi,%rdx,4)
movss  %xmm0,(%rsi,%rdi,4)
movss  %xmm1,(%rsi,%rbp,4)
add    %r12d,%eax
add    %r13d,%ecx
cltq
mov    (%rsi,%rax,4),%rdx
movslq %ecx,%rcx
movss  (%rsi,%rcx,4),%xmm0
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdx,(%rsi,%rcx,4)
mov    -0x2c(%rsp),%eax
mov    %eax,%ecx
nopl   0x0(%rax,%rax,1)
xor    %eax,%r8d
sar    %ecx
cmp    %r8d,%eax
mov    %ecx,%eax
jg     15c0 <bitrv2+0x4c0>
mov    -0x18(%rsp),%rcx
add    $0x4,%ecx
cmp    %r12d,%ecx
jl     1170 <bitrv2+0x70>
jmp    182d <bitrv2+0x72d>
test   %r12d,%r12d
jle    182d <bitrv2+0x72d>
sarl   $0x2,-0x2c(%rsp)
mov    %r12d,%r14d
movslq -0x28(%rsp),%r15
xor    %r10d,%r10d
xor    %ecx,%ecx
mov    -0x28(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rcx,1),%eax
movslq %eax,%r11
mov    %rcx,-0x20(%rsp)
test   %ecx,%ecx
je     17a7 <bitrv2+0x6a7>
movslq %r10d,%rcx
mov    -0x20(%rsp),%rax
mov    %eax,%edx
xchg   %ax,%ax
mov    (%rsi,%rcx,4),%rax
movslq %edx,%rdi
movss  (%rsi,%rdi,4),%xmm0
movss  0x4(%rsi,%rdi,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rax,(%rsi,%rdi,4)
lea    (%rcx,%r14,1),%rax
lea    (%rdi,%r12,1),%ebp
mov    (%rsi,%rax,4),%rbx
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  0x4(%rsi,%rbp,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rbx,(%rsi,%rbp,4)
add    %r15,%rax
add    %r12d,%edi
add    $0x2,%edi
mov    (%rsi,%rax,4),%rbx
movss  0x8(%rsi,%rbp,4),%xmm0
movss  0xc(%rsi,%rbp,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rbx,0x8(%rsi,%rbp,4)
mov    %rax,%rbx
sub    %r14,%rbx
sub    %r12d,%edi
mov    (%rsi,%rbx,4),%r13
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
movss  0x4(%rsi,%rdi,4),%xmm1
movss  %xmm0,(%rsi,%rbx,4)
movss  %xmm1,0x4(%rsi,%rbx,4)
mov    %r13,(%rsi,%rdi,4)
add    %r9d,%edi
mov    0x8(%rsi,%rbx,4),%r13
movslq %edi,%rdi
mov    (%rsi,%rdi,4),%r8
mov    %r8,0x8(%rsi,%rbx,4)
mov    %r13,(%rsi,%rdi,4)
lea    0x2(%rax),%edi
lea    (%r15,%rbp,1),%r8d
add    $0x2,%r8d
movslq %edi,%rdi
movss  (%rsi,%rdi,4),%xmm0
shl    $0x20,%rax
movabs $0x300000000,%rbx
add    %rbx,%rax
sar    $0x1e,%rax
movss  (%rsi,%rax,1),%xmm1
movslq %r8d,%rbx
movss  (%rsi,%rbx,4),%xmm2
movss  0x4(%rsi,%rbx,4),%xmm3
movss  %xmm2,(%rsi,%rdi,4)
movss  %xmm3,(%rsi,%rax,1)
movss  %xmm0,(%rsi,%rbx,4)
movss  %xmm1,0x4(%rsi,%rbx,4)
sub    %r15d,%edi
add    %r9d,%ebp
movslq %edi,%rax
mov    (%rsi,%rax,4),%rdi
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  0x4(%rsi,%rbp,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdi,(%rsi,%rbp,4)
sub    %r12d,%eax
sub    %r12d,%ebp
cltq
mov    (%rsi,%rax,4),%rdi
movslq %ebp,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  0x4(%rsi,%rbp,4),%xmm1
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,0x4(%rsi,%rax,4)
mov    %rdi,(%rsi,%rbp,4)
mov    -0x2c(%rsp),%eax
mov    %eax,%edi
xchg   %ax,%ax
xor    %eax,%edx
sar    %edi
cmp    %edx,%eax
mov    %edi,%eax
jg     1790 <bitrv2+0x690>
add    $0x4,%rcx
cmp    %r11,%rcx
jl     1630 <bitrv2+0x530>
mov    -0x28(%rsp),%rax
add    %r11d,%eax
mov    0x8(%rsi,%r11,4),%rcx
cltq
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
movss  %xmm0,0x8(%rsi,%r11,4)
movss  %xmm1,0xc(%rsi,%r11,4)
mov    %rcx,(%rsi,%rax,4)
lea    (%r11,%r12,1),%ecx
add    $0x2,%ecx
add    %r12d,%eax
movslq %ecx,%rcx
mov    (%rsi,%rcx,4),%rdx
cltq
movss  (%rsi,%rax,4),%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
movss  %xmm0,(%rsi,%rcx,4)
movss  %xmm1,0x4(%rsi,%rcx,4)
mov    %rdx,(%rsi,%rax,4)
mov    -0x2c(%rsp),%eax
mov    %eax,%ecx
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%r10d
sar    %ecx
cmp    %r10d,%eax
mov    %ecx,%eax
jg     1810 <bitrv2+0x710>
mov    -0x20(%rsp),%rcx
add    $0x4,%ecx
cmp    %r12d,%ecx
jl     1610 <bitrv2+0x510>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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