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


x86 assembly (clang, -O0):
<bitrv2conj>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jle    1140 <bitrv2conj+0x40>
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    111f <bitrv2conj+0x1f>
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jne    24d9 <bitrv2conj+0x13d9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    24d4 <bitrv2conj+0x13d4>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1eec <bitrv2conj+0xdec>
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1176 <bitrv2conj+0x76>
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
sub    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
sub    $0x2,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1163 <bitrv2conj+0x63>
jmp    2e47 <bitrv2conj+0x1d47>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2e42 <bitrv2conj+0x1d42>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    2bb7 <bitrv2conj+0x1ab7>
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    24f3 <bitrv2conj+0x13f3>
mov    -0x24(%rbp),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    24e0 <bitrv2conj+0x13e0>
jmp    2e47 <bitrv2conj+0x1d47>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitrv2conj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %edi,%r11d
mov    $0x1,%eax
mov    %edi,%ecx
nopl   0x0(%rax,%rax,1)
mov    %eax,%r15d
mov    %ecx,%edi
sar    $0x2,%ecx
lea    (%r15,%r15,1),%eax
cmp    $0x23,%edi
jg     1120 <bitrv2conj+0x20>
sar    %r11d
lea    0x0(,%r15,4),%r13d
cmp    $0x8,%ecx
mov    %rsi,-0x8(%rsp)
jne    1a49 <bitrv2conj+0x949>
test   %r15d,%r15d
jle    1e8d <bitrv2conj+0xd8d>
movslq %r13d,%rax
movslq %r11d,%rcx
mov    %r15d,%r9d
shl    $0x3,%r15d
lea    (%rdx,%rax,4),%rdi
add    $0x4,%rdi
mov    %rdi,0x70(%rsp)
mov    %rax,%rdi
lea    (%rax,%rax,2),%rbp
lea    (%rcx,%rbp,1),%rbx
mov    %rbx,0x68(%rsp)
lea    (%rcx,%rax,2),%rbx
mov    %rbx,0x60(%rsp)
lea    (%rdx,%rcx,4),%rbx
add    %rax,%rcx
mov    %rcx,0x80(%rsp)
lea    (%rbx,%rax,8),%rcx
mov    %rcx,0x50(%rsp)
lea    (%rdx,%rax,8),%rcx
mov    %rcx,0x48(%rsp)
shl    $0x21,%rax
mov    %rax,0x40(%rsp)
shl    $0x20,%rdi
lea    (%rdi,%rdi,2),%rax
mov    %rax,0x38(%rsp)
mov    %rbx,0x58(%rsp)
lea    (%rbx,%rbp,4),%rax
mov    %rax,0x30(%rsp)
lea    (%rdx,%rbp,4),%rax
mov    %rax,0x28(%rsp)
movaps 0xe25(%rip),%xmm0
lea    (%rsi,%r9,4),%r10
lea    0x4(%rdx),%rax
mov    %rax,0x20(%rsp)
lea    0x0(%r13,%r13,2),%eax
mov    %rax,0x18(%rsp)
add    %r11d,%eax
add    $0x2,%eax
mov    %rax,0x10(%rsp)
xor    %r14d,%r14d
xor    %r12d,%r12d
mov    %r9,0x78(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x98(%rsp)
jmp    140f <bitrv2conj+0x30f>
nopw   0x0(%rax,%rax,1)
movslq (%rsi,%rax,4),%rax
movslq %ecx,%rcx
lea    (%rcx,%rax,2),%rax
lea    (%rax,%r13,1),%ebx
movslq %eax,%rcx
lea    (%rax,%r11,1),%edi
shl    $0x2,%rax
or     $0x4,%rax
movss  (%rdx,%rax,1),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,1)
movss  0x8(%rdx,%rcx,4),%xmm1
movss  0xc(%rdx,%rcx,4),%xmm2
xorps  %xmm0,%xmm2
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm3
movss  0x4(%rdx,%rdi,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,0x8(%rdx,%rcx,4)
movss  %xmm4,0xc(%rdx,%rcx,4)
movss  %xmm1,(%rdx,%rdi,4)
movss  %xmm2,0x4(%rdx,%rdi,4)
movss  0xc(%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx,%rdi,4)
lea    (%rcx,%r13,1),%eax
add    $0x2,%eax
add    %r15d,%edi
cltq
movss  (%rdx,%rax,4),%xmm1
mov    %eax,%ecx
or     $0x1,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm2
xorps  %xmm0,%xmm2
movslq %edi,%rbp
movss  (%rdx,%rbp,4),%xmm3
movss  0x4(%rdx,%rbp,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm1,(%rdx,%rbp,4)
movss  %xmm2,0x4(%rdx,%rbp,4)
lea    (%rbx,%r13,1),%eax
add    $0x2,%eax
sub    %r13d,%ebp
movslq %eax,%rdi
movss  (%rdx,%rdi,4),%xmm1
mov    %edi,%eax
or     $0x1,%eax
cltq
movss  (%rdx,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ebp,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rdi,4)
movss  %xmm4,(%rdx,%rax,4)
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,0x4(%rdx,%rbx,4)
mov    %ebx,%eax
sub    %r11d,%eax
movss  -0x8(%rdx,%rdi,4),%xmm1
movss  -0x4(%rdx,%rdi,4),%xmm2
xorps  %xmm0,%xmm2
cltq
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,-0x8(%rdx,%rdi,4)
movss  %xmm4,-0x4(%rdx,%rdi,4)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,0x4(%rdx,%rax,4)
lea    (%rdi,%r11,1),%eax
lea    0x2(%rbx),%ecx
cltq
movss  (%rdx,%rax,4),%xmm1
movss  0x4(%rdx,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm3
lea    0x3(%rbx),%ebp
movslq %ebp,%rbp
movss  (%rdx,%rbp,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,0x4(%rdx,%rax,4)
movss  %xmm1,(%rdx,%rcx,4)
movss  %xmm2,(%rdx,%rbp,4)
lea    (%rdi,%r13,1),%eax
add    %r15d,%ebx
cltq
movss  -0x4(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rax,4)
movss  (%rdx,%rax,4),%xmm1
mov    %eax,%ecx
or     $0x1,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ebx,%rdi
movss  (%rdx,%rdi,4),%xmm3
movss  0x4(%rdx,%rdi,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm1,(%rdx,%rdi,4)
movss  %xmm2,0x4(%rdx,%rdi,4)
movss  0xc(%rdx,%rdi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx,%rdi,4)
add    $0x1,%r12
add    $0x4,%r14
cmp    %r9,%r12
je     1e8d <bitrv2conj+0xd8d>
lea    (%r12,%r9,1),%rax
mov    $0x0,%ecx
test   %r12,%r12
je     1220 <bitrv2conj+0x120>
mov    %rax,0x88(%rsp)
movslq (%rsi,%rax,4),%rdi
lea    (%rdi,%rdi,1),%rsi
mov    %r12,0x90(%rsp)
movslq %r12d,%rax
shl    $0x2,%rax
mov    %rax,-0x78(%rsp)
lea    (%rdx,%rdi,8),%rax
mov    %rax,-0x18(%rsp)
mov    0x70(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    %rax,-0x30(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%rdi,2),%rbx
mov    0x58(%rsp),%rax
lea    (%rax,%rdi,8),%r12
mov    0x50(%rsp),%rax
mov    %r14,-0x80(%rsp)
lea    (%rax,%rdi,8),%r14
mov    0x30(%rsp),%rax
lea    (%rax,%rdi,8),%r8
mov    0x28(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    %rax,-0x28(%rsp)
mov    0x48(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    %rax,-0x38(%rsp)
shl    $0x21,%rdi
mov    0x40(%rsp),%rax
add    %rdi,%rax
mov    %rax,-0x48(%rsp)
add    0x38(%rsp),%rdi
mov    %rdi,-0x40(%rsp)
mov    0x68(%rsp),%rax
lea    (%rax,%rsi,1),%ecx
shl    $0x20,%rcx
movabs $0x300000000,%rax
add    %rax,%rcx
mov    %rcx,-0x50(%rsp)
mov    %esi,%ecx
mov    %rcx,-0x58(%rsp)
lea    (%rsi,%r13,1),%ecx
mov    %rcx,-0x60(%rsp)
lea    (%r15,%rsi,1),%ecx
mov    %rcx,-0x68(%rsp)
mov    0x18(%rsp),%rcx
add    %esi,%ecx
mov    %rcx,-0x70(%rsp)
mov    0x10(%rsp),%rcx
add    %esi,%ecx
mov    %rcx,0xb0(%rsp)
add    0x60(%rsp),%esi
shl    $0x20,%rsi
lea    (%rsi,%rax,1),%rcx
mov    %rcx,0xa8(%rsp)
movabs $0x200000000,%rcx
add    %rcx,%rsi
mov    %rsi,-0x10(%rsp)
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbx,4),%r9
shl    $0x20,%rbx
add    %rbx,%rax
mov    %rax,0xa0(%rsp)
add    %rcx,%rbx
mov    %rbx,-0x20(%rsp)
xor    %edi,%edi
xor    %r10d,%r10d
nopl   0x0(%rax)
mov    0x98(%rsp),%rax
movslq (%rax,%r10,1),%rbx
mov    -0x78(%rsp),%rax
lea    (%rax,%rbx,2),%rbx
mov    -0x18(%rsp),%rcx
movss  (%rcx,%r10,4),%xmm1
movss  0x4(%rcx,%r10,4),%xmm2
movss  (%rdx,%rbx,4),%xmm3
mov    %ebx,%eax
or     $0x1,%eax
cltq
movss  (%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm3,(%rcx,%r10,4)
movss  %xmm4,0x4(%rcx,%r10,4)
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,(%rdx,%rax,4)
lea    (%rbx,%r15,1),%eax
mov    -0x30(%rsp),%rcx
movss  -0x4(%rcx,%r10,4),%xmm1
movss  (%rcx,%r10,4),%xmm2
cltq
movss  (%rdx,%rax,4),%xmm3
mov    %eax,%ebx
or     $0x1,%ebx
xorps  %xmm0,%xmm2
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,-0x4(%rcx,%r10,4)
movss  %xmm4,(%rcx,%r10,4)
movss  %xmm1,(%rdx,%rax,4)
sub    %r13d,%eax
movss  %xmm2,(%rdx,%rbx,4)
mov    -0x48(%rsp),%rcx
add    %rdi,%rcx
sar    $0x1e,%rcx
or     $0x4,%rcx
mov    -0x38(%rsp),%rsi
movss  (%rsi,%r10,4),%xmm1
movss  (%rdx,%rcx,1),%xmm2
movslq %eax,%rbx
movss  (%rdx,%rbx,4),%xmm3
mov    %ebx,%eax
xorps  %xmm0,%xmm2
or     $0x1,%eax
cltq
movss  (%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rsi,%r10,4)
movss  %xmm4,(%rdx,%rcx,1)
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,(%rdx,%rax,4)
lea    (%rbx,%r15,1),%eax
mov    -0x40(%rsp),%rcx
add    %rdi,%rcx
sar    $0x1e,%rcx
mov    -0x28(%rsp),%rbp
movss  0x0(%rbp,%r10,4),%xmm1
or     $0x4,%rcx
movss  (%rdx,%rcx,1),%xmm2
cltq
mov    %eax,%esi
movss  (%rdx,%rax,4),%xmm3
or     $0x1,%esi
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm4
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm3,0x0(%rbp,%r10,4)
movss  %xmm4,(%rdx,%rcx,1)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,(%rdx,%rsi,4)
movss  (%r8,%r10,4),%xmm1
movss  0x4(%r8,%r10,4),%xmm2
xorps  %xmm0,%xmm2
movss  0x8(%rdx,%rax,4),%xmm3
movss  0xc(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%r8,%r10,4)
movss  %xmm4,0x4(%r8,%r10,4)
movss  %xmm1,0x8(%rdx,%rax,4)
lea    0x2(%rbx),%ecx
movss  %xmm2,0xc(%rdx,%rax,4)
movss  (%r14,%r10,4),%xmm1
movss  0x4(%r14,%r10,4),%xmm2
movslq %ecx,%rax
xorps  %xmm0,%xmm2
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%r14,%r10,4)
movss  %xmm4,0x4(%r14,%r10,4)
movss  %xmm1,(%rdx,%rax,4)
lea    0x2(%rbx,%r13,1),%ecx
movss  %xmm2,0x4(%rdx,%rax,4)
movss  -0x4(%r9,%r10,4),%xmm1
movss  (%r9,%r10,4),%xmm2
movslq %ecx,%rbx
xorps  %xmm0,%xmm2
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,-0x4(%r9,%r10,4)
movss  %xmm4,(%r9,%r10,4)
movss  %xmm1,(%rdx,%rbx,4)
mov    %ebx,%eax
sub    %r15d,%eax
movss  %xmm2,0x4(%rdx,%rbx,4)
movss  (%r12,%r10,4),%xmm1
movss  0x4(%r12,%r10,4),%xmm2
cltq
xorps  %xmm0,%xmm2
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%r12,%r10,4)
movss  %xmm4,0x4(%r12,%r10,4)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,0x4(%rdx,%rax,4)
mov    0x8(%rsp),%rcx
add    %ecx,%eax
movss  0x8(%r12,%r10,4),%xmm1
movss  0xc(%r12,%r10,4),%xmm2
cltq
xorps  %xmm0,%xmm2
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,0x8(%r12,%r10,4)
movss  %xmm4,0xc(%r12,%r10,4)
movss  %xmm1,(%rdx,%rax,4)
add    %ecx,%ebx
movss  %xmm2,0x4(%rdx,%rax,4)
mov    -0x20(%rsp),%rax
add    %rdi,%rax
sar    $0x1e,%rax
mov    0xa0(%rsp),%rcx
add    %rdi,%rcx
movss  (%rdx,%rax,1),%xmm1
sar    $0x1e,%rcx
movss  (%rdx,%rcx,1),%xmm2
movslq %ebx,%rsi
xorps  %xmm0,%xmm2
movss  (%rdx,%rsi,4),%xmm3
movss  0x4(%rdx,%rsi,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,1)
movss  %xmm4,(%rdx,%rcx,1)
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm2,0x4(%rdx,%rsi,4)
sub    %r13d,%esi
mov    -0x10(%rsp),%rax
add    %rdi,%rax
sar    $0x1e,%rax
mov    0xa8(%rsp),%rcx
add    %rdi,%rcx
movss  (%rdx,%rax,1),%xmm1
sar    $0x1e,%rcx
movss  (%rdx,%rcx,1),%xmm2
mov    %r15,%r11
mov    %r13,%r15
movslq %esi,%r13
xorps  %xmm0,%xmm2
movss  (%rdx,%r13,4),%xmm3
movss  0x4(%rdx,%r13,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,1)
movss  %xmm4,(%rdx,%rcx,1)
movss  %xmm1,(%rdx,%r13,4)
mov    0xb0(%rsp),%rax
add    %r10d,%eax
movss  %xmm2,0x4(%rdx,%r13,4)
lea    0x0(%r13,%r11,1),%ecx
cltq
mov    -0x50(%rsp),%rsi
add    %rdi,%rsi
movss  (%rdx,%rax,4),%xmm1
sar    $0x1e,%rsi
movss  (%rdx,%rsi,1),%xmm2
movslq %ecx,%rbx
xorps  %xmm0,%xmm2
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rsi,1)
movss  %xmm1,(%rdx,%rbx,4)
mov    -0x70(%rsp),%rcx
lea    0x2(%rcx,%r10,1),%eax
movss  %xmm2,0x4(%rdx,%rbx,4)
cltq
lea    0x3(%rcx,%r10,1),%ecx
movslq %ecx,%rcx
movss  (%rdx,%rax,4),%xmm1
movss  (%rdx,%rcx,4),%xmm2
movss  -0x8(%rdx,%rbx,4),%xmm3
movss  -0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm1,-0x8(%rdx,%rbx,4)
mov    -0x68(%rsp),%rsi
lea    0x2(%rsi,%r10,1),%eax
lea    -0x2(%r13),%ecx
cltq
movss  %xmm2,-0x4(%rdx,%rbx,4)
movss  (%rdx,%rax,4),%xmm1
lea    0x3(%rsi,%r10,1),%esi
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm2
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm3
movss  0x4(%rdx,%rcx,4),%xmm4
movss  %xmm3,(%rdx,%rax,4)
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm4,(%rdx,%rsi,4)
movss  %xmm1,(%rdx,%rcx,4)
mov    -0x60(%rsp),%rbx
lea    0x2(%rbx,%r10,1),%eax
lea    -0x2(%r13,%r15,1),%esi
mov    %r15,%r13
mov    %r11,%r15
cltq
movss  %xmm2,0x4(%rdx,%rcx,4)
movss  (%rdx,%rax,4),%xmm1
lea    0x3(%rbx,%r10,1),%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm2
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm3
movss  0x4(%rdx,%rsi,4),%xmm4
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rcx,4)
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm2,0x4(%rdx,%rsi,4)
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r10,1),%eax
add    $0x2,%eax
cltq
sub    %r15d,%esi
movss  (%rdx,%rax,4),%xmm1
add    %r10d,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm2
movslq %esi,%rsi
movss  (%rdx,%rsi,4),%xmm3
movss  0x4(%rdx,%rsi,4),%xmm4
movss  %xmm3,(%rdx,%rax,4)
xorps  %xmm0,%xmm4
movss  %xmm4,(%rdx,%rcx,4)
xorps  %xmm0,%xmm2
movss  %xmm1,(%rdx,%rsi,4)
movss  %xmm2,0x4(%rdx,%rsi,4)
add    $0x4,%r10
movabs $0x400000000,%rax
add    %rax,%rdi
cmp    %r10,-0x80(%rsp)
jne    1560 <bitrv2conj+0x460>
mov    -0x8(%rsp),%rsi
mov    0x8(%rsp),%r11
mov    0x78(%rsp),%r9
mov    -0x80(%rsp),%r14
mov    0x90(%rsp),%r12
mov    0x88(%rsp),%rax
mov    -0x78(%rsp),%rcx
jmp    1220 <bitrv2conj+0x120>
test   %r15d,%r15d
jle    1e8d <bitrv2conj+0xd8d>
movslq %r13d,%r12
movslq %r11d,%rax
mov    %r15d,%edi
mov    %rax,%r15
lea    (%rsi,%rdi,4),%r9
add    %r12,%rax
mov    %rax,-0x50(%rsp)
lea    0x2(%r15,%r12,1),%eax
mov    %rax,-0x58(%rsp)
lea    (%rdx,%r15,4),%rax
mov    %rax,-0x60(%rsp)
lea    0x4(%rdx),%rax
mov    %rax,-0x68(%rsp)
lea    (%rdx,%r12,4),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rsp)
xor    %r14d,%r14d
movaps 0x563(%rip),%xmm0
xor    %ebp,%ebp
mov    %rdi,-0x48(%rsp)
mov    %r13,(%rsp)
jmp    1b84 <bitrv2conj+0xa84>
nopl   (%rax)
movslq (%rsi,%rax,4),%rax
movslq %ebx,%rcx
add    %rax,%rcx
movss  0x4(%rdx,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%rdx,%rcx,4)
movslq %ecx,%rax
add    %r11d,%ecx
movss  0x8(%rdx,%rax,4),%xmm1
movss  0xc(%rdx,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm3
movss  0x4(%rdx,%rcx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,0x8(%rdx,%rax,4)
movss  %xmm4,0xc(%rdx,%rax,4)
movss  %xmm1,(%rdx,%rcx,4)
movss  %xmm2,0x4(%rdx,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx,%rcx,4)
add    %r13d,%eax
add    $0x2,%eax
add    %r13d,%ecx
cltq
movss  -0x4(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdx,%rax,4)
movss  (%rdx,%rax,4),%xmm1
movss  0x4(%rdx,%rax,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ecx,%rcx
movss  (%rdx,%rcx,4),%xmm3
movss  0x4(%rdx,%rcx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,0x4(%rdx,%rax,4)
movss  %xmm1,(%rdx,%rcx,4)
movss  %xmm2,0x4(%rdx,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx,%rcx,4)
add    $0x1,%rbp
add    $0x4,%r14
cmp    %rdi,%rbp
je     1e8d <bitrv2conj+0xd8d>
lea    (%rdi,%rbp,1),%rax
mov    $0x0,%ebx
test   %rbp,%rbp
je     1ab0 <bitrv2conj+0x9b0>
mov    %rax,-0x40(%rsp)
mov    (%rsi,%rax,4),%eax
mov    %rbp,-0x38(%rsp)
movslq %ebp,%rbx
shl    $0x2,%rbx
mov    %rax,-0x80(%rsp)
cltq
mov    -0x50(%rsp),%rcx
add    %rax,%rcx
mov    -0x68(%rsp),%rsi
lea    (%rsi,%rcx,4),%rsi
mov    %rsi,-0x10(%rsp)
shl    $0x20,%rcx
movabs $0x300000000,%rsi
add    %rsi,%rcx
lea    (%rax,%r13,1),%esi
mov    %rsi,-0x18(%rsp)
mov    -0x58(%rsp),%rsi
add    %eax,%esi
mov    %rsi,-0x20(%rsp)
mov    -0x60(%rsp),%rsi
lea    (%rsi,%rax,4),%r8
mov    -0x70(%rsp),%rsi
lea    (%rsi,%rax,4),%rsi
mov    %rsi,-0x28(%rsp)
lea    (%rdx,%rax,4),%rax
mov    %rax,-0x30(%rsp)
xor    %ebp,%ebp
mov    %rbx,-0x78(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%r9,%rbp,1),%rax
add    %rbx,%rax
mov    -0x30(%rsp),%rsi
movss  (%rsi,%rbp,4),%xmm1
movss  0x4(%rsi,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
movss  (%rdx,%rax,4),%xmm3
movslq %eax,%rdi
movss  0x4(%rdx,%rdi,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rsi,%rbp,4)
movss  %xmm4,0x4(%rsi,%rbp,4)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,0x4(%rdx,%rdi,4)
mov    (%rsp),%r13
lea    (%rdi,%r13,1),%eax
mov    -0x28(%rsp),%rsi
movss  -0x4(%rsi,%rbp,4),%xmm1
movss  (%rsi,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
movslq %eax,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,-0x4(%rsi,%rbp,4)
movss  %xmm4,(%rsi,%rbp,4)
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,0x4(%rdx,%rbx,4)
lea    0x2(%rdi,%r12,1),%eax
mov    -0x10(%rsp),%rdi
movss  -0x4(%rdi,%rbp,4),%xmm1
movss  (%rdi,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
movss  0x8(%rdx,%rbx,4),%xmm3
movss  0xc(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,-0x4(%rdi,%rbp,4)
movss  %xmm4,(%rdi,%rbp,4)
movss  %xmm1,0x8(%rdx,%rbx,4)
movss  %xmm2,0xc(%rdx,%rbx,4)
sub    %r13d,%eax
movss  (%r8,%rbp,4),%xmm1
movss  0x4(%r8,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
cltq
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%r8,%rbp,4)
movss  %xmm4,0x4(%r8,%rbp,4)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,0x4(%rdx,%rax,4)
add    %r11d,%eax
movss  0x8(%r8,%rbp,4),%xmm1
movss  0xc(%r8,%rbp,4),%xmm2
xorps  %xmm0,%xmm2
cltq
movss  (%rdx,%rax,4),%xmm3
movss  0x4(%rdx,%rax,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,0x8(%r8,%rbp,4)
movss  %xmm4,0xc(%r8,%rbp,4)
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm2,0x4(%rdx,%rax,4)
mov    -0x20(%rsp),%rax
add    %ebp,%eax
lea    0x2(%r15,%rbx,1),%edi
cltq
movss  (%rdx,%rax,4),%xmm1
mov    %r9,%r10
mov    %r15,%r9
mov    %r12,%r15
mov    %r11,%r12
mov    %rcx,%r11
sar    $0x1e,%r11
movss  (%rdx,%r11,1),%xmm2
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm3
movss  0x4(%rdx,%rdi,4),%xmm4
movss  %xmm3,(%rdx,%rax,4)
xorps  %xmm0,%xmm2
xorps  %xmm0,%xmm4
movss  %xmm4,(%rdx,%r11,1)
mov    %r12,%r11
mov    %r15,%r12
mov    %r9,%r15
mov    %r10,%r9
movss  %xmm1,(%rdx,%rdi,4)
movss  %xmm2,0x4(%rdx,%rdi,4)
mov    -0x18(%rsp),%rdi
lea    (%rdi,%rbp,1),%eax
add    $0x2,%eax
add    %r11d,%ebx
cltq
movss  (%rdx,%rax,4),%xmm1
add    %ebp,%edi
add    $0x3,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm2
xorps  %xmm0,%xmm2
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
xorps  %xmm0,%xmm4
movss  %xmm3,(%rdx,%rax,4)
movss  %xmm4,(%rdx,%rdi,4)
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,0x4(%rdx,%rbx,4)
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rbp,1),%eax
add    $0x2,%eax
sub    %r13d,%ebx
cltq
movss  (%rdx,%rax,4),%xmm1
add    %ebp,%edi
add    $0x3,%edi
movslq %edi,%rdi
movss  (%rdx,%rdi,4),%xmm2
movslq %ebx,%rbx
movss  (%rdx,%rbx,4),%xmm3
movss  0x4(%rdx,%rbx,4),%xmm4
movss  %xmm3,(%rdx,%rax,4)
xorps  %xmm0,%xmm4
movss  %xmm4,(%rdx,%rdi,4)
movabs $0x400000000,%rax
xorps  %xmm0,%xmm2
movss  %xmm1,(%rdx,%rbx,4)
movss  %xmm2,0x4(%rdx,%rbx,4)
mov    -0x78(%rsp),%rbx
add    $0x4,%rbp
add    %rax,%rcx
cmp    %rbp,%r14
jne    1c20 <bitrv2conj+0xb20>
mov    -0x8(%rsp),%rsi
mov    (%rsp),%r13
mov    -0x48(%rsp),%rdi
mov    -0x38(%rsp),%rbp
mov    -0x40(%rsp),%rax
jmp    1ab0 <bitrv2conj+0x9b0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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