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