int check_rotation(double rot[2][3]) {
  double v1[3], v2[3], v3[3];
  double ca, cb, k1, k2, k3, k4;
  double a, b, c, d;
  double p1, q1, r1;
  double p2, q2, r2;
  double p3, q3, r3;
  double p4, q4, r4;
  double w;
  double e1, e2, e3, e4;
  int f;
  v1[0] = rot[0][0];
  v1[1] = rot[0][1];
  v1[2] = rot[0][2];
  v2[0] = rot[1][0];
  v2[1] = rot[1][1];
  v2[2] = rot[1][2];
  v3[0] = v1[1] * v2[2] - v1[2] * v2[1];
  v3[1] = v1[2] * v2[0] - v1[0] * v2[2];
  v3[2] = v1[0] * v2[1] - v1[1] * v2[0];
  w = sqrt(v3[0] * v3[0] + v3[1] * v3[1] + v3[2] * v3[2]);
  if (w == 0.0)
    return -1;
  v3[0] /= w;
  v3[1] /= w;
  v3[2] /= w;
  cb = v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
  if (cb < 0)
    cb *= -1.0;
  ca = (sqrt(cb + 1.0) + sqrt(1.0 - cb)) * 0.5;
  if (v3[1] * v1[0] - v1[1] * v3[0] != 0.0) {
    f = 0;
  } else {
    if (v3[2] * v1[0] - v1[2] * v3[0] != 0.0) {
      w = v1[1];
      v1[1] = v1[2];
      v1[2] = w;
      w = v3[1];
      v3[1] = v3[2];
      v3[2] = w;
      f = 1;
    } else {
      w = v1[0];
      v1[0] = v1[2];
      v1[2] = w;
      w = v3[0];
      v3[0] = v3[2];
      v3[2] = w;
      f = 2;
    }
  }
  if (v3[1] * v1[0] - v1[1] * v3[0] == 0.0)
    return -1;
  k1 = (v1[1] * v3[2] - v3[1] * v1[2]) / (v3[1] * v1[0] - v1[1] * v3[0]);
  k2 = (v3[1] * ca) / (v3[1] * v1[0] - v1[1] * v3[0]);
  k3 = (v1[0] * v3[2] - v3[0] * v1[2]) / (v3[0] * v1[1] - v1[0] * v3[1]);
  k4 = (v3[0] * ca) / (v3[0] * v1[1] - v1[0] * v3[1]);
  a = k1 * k1 + k3 * k3 + 1;
  b = k1 * k2 + k3 * k4;
  c = k2 * k2 + k4 * k4 - 1;
  d = b * b - a * c;
  if (d < 0)
    return -1;
  r1 = (-b + sqrt(d)) / a;
  p1 = k1 * r1 + k2;
  q1 = k3 * r1 + k4;
  r2 = (-b - sqrt(d)) / a;
  p2 = k1 * r2 + k2;
  q2 = k3 * r2 + k4;
  if (f == 1) {
    w = q1;
    q1 = r1;
    r1 = w;
    w = q2;
    q2 = r2;
    r2 = w;
    w = v1[1];
    v1[1] = v1[2];
    v1[2] = w;
    w = v3[1];
    v3[1] = v3[2];
    v3[2] = w;
    f = 0;
  }
  if (f == 2) {
    w = p1;
    p1 = r1;
    r1 = w;
    w = p2;
    p2 = r2;
    r2 = w;
    w = v1[0];
    v1[0] = v1[2];
    v1[2] = w;
    w = v3[0];
    v3[0] = v3[2];
    v3[2] = w;
    f = 0;
  }
  if (v3[1] * v2[0] - v2[1] * v3[0] != 0.0) {
    f = 0;
  } else {
    if (v3[2] * v2[0] - v2[2] * v3[0] != 0.0) {
      w = v2[1];
      v2[1] = v2[2];
      v2[2] = w;
      w = v3[1];
      v3[1] = v3[2];
      v3[2] = w;
      f = 1;
    } else {
      w = v2[0];
      v2[0] = v2[2];
      v2[2] = w;
      w = v3[0];
      v3[0] = v3[2];
      v3[2] = w;
      f = 2;
    }
  }
  if (v3[1] * v2[0] - v2[1] * v3[0] == 0.0)
    return -1;
  k1 = (v2[1] * v3[2] - v3[1] * v2[2]) / (v3[1] * v2[0] - v2[1] * v3[0]);
  k2 = (v3[1] * ca) / (v3[1] * v2[0] - v2[1] * v3[0]);
  k3 = (v2[0] * v3[2] - v3[0] * v2[2]) / (v3[0] * v2[1] - v2[0] * v3[1]);
  k4 = (v3[0] * ca) / (v3[0] * v2[1] - v2[0] * v3[1]);
  a = k1 * k1 + k3 * k3 + 1;
  b = k1 * k2 + k3 * k4;
  c = k2 * k2 + k4 * k4 - 1;
  d = b * b - a * c;
  if (d < 0)
    return -1;
  r3 = (-b + sqrt(d)) / a;
  p3 = k1 * r3 + k2;
  q3 = k3 * r3 + k4;
  r4 = (-b - sqrt(d)) / a;
  p4 = k1 * r4 + k2;
  q4 = k3 * r4 + k4;
  if (f == 1) {
    w = q3;
    q3 = r3;
    r3 = w;
    w = q4;
    q4 = r4;
    r4 = w;
    w = v2[1];
    v2[1] = v2[2];
    v2[2] = w;
    w = v3[1];
    v3[1] = v3[2];
    v3[2] = w;
    f = 0;
  }
  if (f == 2) {
    w = p3;
    p3 = r3;
    r3 = w;
    w = p4;
    p4 = r4;
    r4 = w;
    w = v2[0];
    v2[0] = v2[2];
    v2[2] = w;
    w = v3[0];
    v3[0] = v3[2];
    v3[2] = w;
    f = 0;
  }
  e1 = p1 * p3 + q1 * q3 + r1 * r3;
  if (e1 < 0)
    e1 = -e1;
  e2 = p1 * p4 + q1 * q4 + r1 * r4;
  if (e2 < 0)
    e2 = -e2;
  e3 = p2 * p3 + q2 * q3 + r2 * r3;
  if (e3 < 0)
    e3 = -e3;
  e4 = p2 * p4 + q2 * q4 + r2 * r4;
  if (e4 < 0)
    e4 = -e4;
  if (e1 < e2) {
    if (e1 < e3) {
      if (e1 < e4) {
        rot[0][0] = p1;
        rot[0][1] = q1;
        rot[0][2] = r1;
        rot[1][0] = p3;
        rot[1][1] = q3;
        rot[1][2] = r3;
      } else {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p4;
        rot[1][1] = q4;
        rot[1][2] = r4;
      }
    } else {
      if (e3 < e4) {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p3;
        rot[1][1] = q3;
        rot[1][2] = r3;
      } else {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p4;
        rot[1][1] = q4;
        rot[1][2] = r4;
      }
    }
  } else {
    if (e2 < e3) {
      if (e2 < e4) {
        rot[0][0] = p1;
        rot[0][1] = q1;
        rot[0][2] = r1;
        rot[1][0] = p4;
        rot[1][1] = q4;
        rot[1][2] = r4;
      } else {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p4;
        rot[1][1] = q4;
        rot[1][2] = r4;
      }
    } else {
      if (e3 < e4) {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p3;
        rot[1][1] = q3;
        rot[1][2] = r3;
      } else {
        rot[0][0] = p2;
        rot[0][1] = q2;
        rot[0][2] = r2;
        rot[1][0] = p4;
        rot[1][1] = q4;
        rot[1][2] = r4;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<check_rotation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    127c <check_rotation+0x16c>
jp     127c <check_rotation+0x16c>
movl   $0xffffffff,-0x4(%rbp)
jmp    274a <check_rotation+0x163a>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x30(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    1311 <check_rotation+0x201>
movsd  0x1cf9(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x1cf7(%rip),%xmm0
addsd  -0x80(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x1cdd(%rip),%xmm0
subsd  -0x80(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x158(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  0x1cb4(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13a8 <check_rotation+0x298>
jp     13a8 <check_rotation+0x298>
jmp    13b7 <check_rotation+0x2a7>
movl   $0x0,-0x14c(%rbp)
jmp    14b0 <check_rotation+0x3a0>
movsd  -0x60(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x20(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1402 <check_rotation+0x2f2>
jp     1402 <check_rotation+0x2f2>
jmp    1459 <check_rotation+0x349>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x14c(%rbp)
jmp    14ab <check_rotation+0x39b>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x2,-0x14c(%rbp)
jmp    14b0 <check_rotation+0x3a0>
movsd  -0x68(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1502 <check_rotation+0x3f2>
jp     1502 <check_rotation+0x3f2>
movl   $0xffffffff,-0x4(%rbp)
jmp    274a <check_rotation+0x163a>
movsd  -0x28(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm3
movsd  -0x28(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm3
movsd  -0x28(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x20(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm3
movsd  -0x30(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1968(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18fc(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    1784 <check_rotation+0x674>
movl   $0xffffffff,-0x4(%rbp)
jmp    274a <check_rotation+0x163a>
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x168(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x160(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x14c(%rbp)
jne    1989 <check_rotation+0x879>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x14c(%rbp)
cmpl   $0x2,-0x14c(%rbp)
jne    1a48 <check_rotation+0x938>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x14c(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a93 <check_rotation+0x983>
jp     1a93 <check_rotation+0x983>
jmp    1aa2 <check_rotation+0x992>
movl   $0x0,-0x14c(%rbp)
jmp    1b9b <check_rotation+0xa8b>
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1aed <check_rotation+0x9dd>
jp     1aed <check_rotation+0x9dd>
jmp    1b44 <check_rotation+0xa34>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x14c(%rbp)
jmp    1b96 <check_rotation+0xa86>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x2,-0x14c(%rbp)
jmp    1b9b <check_rotation+0xa8b>
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bed <check_rotation+0xadd>
jp     1bed <check_rotation+0xadd>
movl   $0xffffffff,-0x4(%rbp)
jmp    274a <check_rotation+0x163a>
movsd  -0x48(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm2
mulsd  -0x70(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm3
movsd  -0x50(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x127d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1211(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    1e6f <check_rotation+0xd5f>
movl   $0xffffffff,-0x4(%rbp)
jmp    274a <check_rotation+0x163a>
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x170(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
cmpl   $0x1,-0x14c(%rbp)
jne    2074 <check_rotation+0xf64>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
movsd  -0x120(%rbp),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x14c(%rbp)
cmpl   $0x2,-0x14c(%rbp)
jne    2133 <check_rotation+0x1023>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x14c(%rbp)
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x130(%rbp),%xmm0
ff
jbe    21b3 <check_rotation+0x10a3>
movsd  -0x130(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jbe    2233 <check_rotation+0x1123>
movsd  -0x138(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x100(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jbe    22b3 <check_rotation+0x11a3>
movsd  -0x140(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x118(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x148(%rbp),%xmm0
ff
jbe    2333 <check_rotation+0x1223>
movsd  -0x148(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2548 <check_rotation+0x1438>
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2455 <check_rotation+0x1345>
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    23eb <check_rotation+0x12db>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    2450 <check_rotation+0x1340>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    2543 <check_rotation+0x1433>
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    24d9 <check_rotation+0x13c9>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    253e <check_rotation+0x142e>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    2543 <check_rotation+0x1433>
jmp    2743 <check_rotation+0x1633>
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2650 <check_rotation+0x1540>
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    25e6 <check_rotation+0x14d6>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    264b <check_rotation+0x153b>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    273e <check_rotation+0x162e>
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    26d4 <check_rotation+0x15c4>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    2739 <check_rotation+0x1629>
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    273e <check_rotation+0x162e>
jmp    2743 <check_rotation+0x1633>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_rotation>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0xe8,%rsp
mov    %rdi,%rbx
movsd  (%rdi),%xmm8
movupd 0x8(%rdi),%xmm9
movsd  0x18(%rdi),%xmm3
movupd 0x20(%rdi),%xmm2
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm8,%xmm0
movapd %xmm9,%xmm5
unpckhpd %xmm9,%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm3,%xmm6
subsd  %xmm0,%xmm6
movapd %xmm3,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm9,%xmm0
movapd %xmm8,%xmm7
unpcklpd %xmm9,%xmm7
mulpd  %xmm2,%xmm7
subpd  %xmm0,%xmm7
movapd %xmm6,%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm7,%xmm1
unpckhpd %xmm7,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm6,0x40(%rsp)
movapd %xmm7,0x30(%rsp)
jb     11be <check_rotation+0xae>
xorps  %xmm7,%xmm7
sqrtsd %xmm0,%xmm7
jmp    1223 <check_rotation+0x113>
movapd %xmm2,0x70(%rsp)
movapd %xmm3,0xb0(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm5,0x50(%rsp)
movapd %xmm9,0x20(%rsp)
movapd %xmm8,0x10(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm1,%xmm1
movapd 0x10(%rsp),%xmm8
movapd 0x20(%rsp),%xmm9
movapd 0x50(%rsp),%xmm5
movapd 0xa0(%rsp),%xmm4
movapd 0xb0(%rsp),%xmm3
movapd 0x70(%rsp),%xmm2
movapd %xmm0,%xmm7
mov    $0xffffffff,%r15d
ucomisd %xmm1,%xmm7
jne    1235 <check_rotation+0x125>
jnp    1c8e <check_rotation+0xb7e>
movapd %xmm7,%xmm10
unpcklpd %xmm7,%xmm10
movapd %xmm9,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm8,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm5,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd 0xd97(%rip),%xmm1
xorpd  %xmm0,%xmm1
xorpd  %xmm11,%xmm11
movapd %xmm0,%xmm6
cmpltsd %xmm11,%xmm6
andpd  %xmm6,%xmm1
andnpd %xmm0,%xmm6
orpd   %xmm1,%xmm6
movapd %xmm6,%xmm0
addsd  0xd7c(%rip),%xmm0
ucomisd %xmm11,%xmm0
movapd %xmm2,0x70(%rsp)
movapd %xmm3,0xb0(%rsp)
movapd %xmm4,0xa0(%rsp)
movapd %xmm5,0x50(%rsp)
movapd %xmm9,0x20(%rsp)
movapd %xmm8,0x10(%rsp)
jb     12ce <check_rotation+0x1be>
sqrtsd %xmm0,%xmm15
jmp    130e <check_rotation+0x1fe>
movapd %xmm7,0x60(%rsp)
movapd %xmm10,(%rsp)
movapd %xmm6,0x90(%rsp)
call   1030 <sqrt@plt>
movapd 0x90(%rsp),%xmm6
xorpd  %xmm11,%xmm11
movapd (%rsp),%xmm10
movapd 0x60(%rsp),%xmm7
movapd 0x20(%rsp),%xmm9
movapd %xmm0,%xmm15
movapd 0x40(%rsp),%xmm2
movapd 0x30(%rsp),%xmm4
movapd 0xcde(%rip),%xmm5
xorpd  %xmm9,%xmm5
divsd  %xmm7,%xmm2
divpd  %xmm10,%xmm4
movsd  0xcd8(%rip),%xmm0
subsd  %xmm6,%xmm0
ucomisd %xmm11,%xmm0
jb     1349 <check_rotation+0x239>
sqrtsd %xmm0,%xmm0
jmp    1385 <check_rotation+0x275>
movapd %xmm15,0x60(%rsp)
movapd %xmm2,0x40(%rsp)
movapd %xmm4,0x30(%rsp)
movapd %xmm5,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm5
movapd 0x20(%rsp),%xmm9
movapd 0x30(%rsp),%xmm4
movapd 0x40(%rsp),%xmm2
movapd 0x60(%rsp),%xmm15
movapd 0x50(%rsp),%xmm7
movapd 0x10(%rsp),%xmm11
movapd %xmm4,%xmm6
unpckhpd %xmm4,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm2,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm1,%xmm3
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm3
jne    13bd <check_rotation+0x2ad>
jnp    13e4 <check_rotation+0x2d4>
xor    %ebp,%ebp
unpcklpd %xmm11,%xmm9
movapd %xmm4,%xmm10
movsd  %xmm2,%xmm10
movapd %xmm7,%xmm1
movapd %xmm4,%xmm11
xor    %r14d,%r14d
movapd %xmm9,%xmm7
jmp    1496 <check_rotation+0x386>
movapd %xmm9,%xmm1
mulpd  %xmm4,%xmm5
unpckhpd %xmm5,%xmm5
movapd %xmm4,%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm3,%xmm5
cmpneqsd %xmm8,%xmm5
movq   %xmm5,%rbp
and    $0x1,%ebp
ucomisd %xmm8,%xmm3
jne    141e <check_rotation+0x30e>
jp     141e <check_rotation+0x30e>
movapd %xmm11,%xmm1
movd   %ebp,%xmm3
pshufd $0x44,%xmm3,%xmm3
psllq  $0x3f,%xmm3
psrad  $0x1f,%xmm3
pshufd $0xf5,%xmm3,%xmm10
unpcklpd %xmm11,%xmm7
movdqa %xmm10,%xmm3
pandn  %xmm9,%xmm3
andpd  %xmm10,%xmm7
orpd   %xmm3,%xmm7
movapd %xmm2,%xmm11
jne    1462 <check_rotation+0x352>
movapd %xmm2,%xmm11
jp     1462 <check_rotation+0x352>
movapd %xmm6,%xmm11
unpcklpd %xmm4,%xmm2
andpd  %xmm10,%xmm4
andnpd %xmm2,%xmm10
orpd   %xmm4,%xmm10
mov    $0x2,%r14d
sub    %ebp,%r14d
pshufd $0xee,%xmm10,%xmm4
mulsd  %xmm7,%xmm4
pshufd $0xee,%xmm7,%xmm3
mulsd  %xmm10,%xmm3
subsd  %xmm4,%xmm3
ucomisd %xmm8,%xmm3
jne    14a3 <check_rotation+0x393>
jnp    1c8e <check_rotation+0xb7e>
addsd  %xmm0,%xmm15
mulsd  0xb67(%rip),%xmm15
unpcklpd %xmm1,%xmm1
mulpd  %xmm10,%xmm1
movapd %xmm11,%xmm4
unpcklpd %xmm11,%xmm4
mulpd  %xmm7,%xmm4
subpd  %xmm1,%xmm4
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm10,%xmm12
unpckhpd %xmm10,%xmm12
mulsd  %xmm12,%xmm7
subsd  %xmm0,%xmm7
unpcklpd %xmm7,%xmm3
divpd  %xmm3,%xmm4
movapd %xmm15,%xmm2
unpcklpd %xmm15,%xmm2
mulpd  %xmm10,%xmm2
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm4,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm1,%xmm6
addsd  0xae9(%rip),%xmm6
divpd  %xmm3,%xmm2
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm4,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0xac5(%rip),%xmm0
mulsd  %xmm6,%xmm0
movapd %xmm3,%xmm7
mulsd  %xmm3,%xmm7
subsd  %xmm0,%xmm7
xorpd  %xmm0,%xmm0
ucomisd %xmm7,%xmm0
ja     1c8e <check_rotation+0xb7e>
movapd 0xa7f(%rip),%xmm1
xorpd  %xmm3,%xmm1
sqrtsd %xmm7,%xmm5
ucomisd %xmm0,%xmm7
movapd %xmm5,%xmm13
movapd %xmm15,0x60(%rsp)
movapd %xmm4,0x50(%rsp)
movaps %xmm10,0x40(%rsp)
movapd %xmm12,0x30(%rsp)
movapd %xmm11,0x20(%rsp)
movapd %xmm2,0x10(%rsp)
movapd %xmm6,(%rsp)
movapd %xmm3,0x90(%rsp)
movapd %xmm1,0xc0(%rsp)
jae    1643 <check_rotation+0x533>
movapd %xmm7,%xmm0
movapd %xmm7,0x80(%rsp)
movapd %xmm5,0xd0(%rsp)
call   1030 <sqrt@plt>
movapd 0xd0(%rsp),%xmm5
movapd 0x80(%rsp),%xmm7
movapd 0xc0(%rsp),%xmm1
movapd 0x90(%rsp),%xmm3
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm2
movapd 0x20(%rsp),%xmm11
movapd 0x30(%rsp),%xmm12
movapd 0x40(%rsp),%xmm10
movapd 0x50(%rsp),%xmm4
movapd 0x60(%rsp),%xmm15
movapd %xmm0,%xmm13
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm7
jae    16ad <check_rotation+0x59d>
movapd %xmm7,%xmm0
movapd %xmm13,0x80(%rsp)
call   1030 <sqrt@plt>
movapd 0xc0(%rsp),%xmm1
movapd 0x90(%rsp),%xmm3
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm2
movapd 0x20(%rsp),%xmm11
movapd 0x30(%rsp),%xmm12
movapd 0x40(%rsp),%xmm10
movapd 0x80(%rsp),%xmm13
movapd 0x50(%rsp),%xmm4
movapd 0x60(%rsp),%xmm15
movapd %xmm0,%xmm5
unpcklpd %xmm1,%xmm13
unpcklpd %xmm5,%xmm3
subpd  %xmm3,%xmm13
unpcklpd %xmm6,%xmm6
divpd  %xmm6,%xmm13
movapd %xmm13,%xmm14
unpcklpd %xmm13,%xmm14
mulpd  %xmm4,%xmm14
addpd  %xmm2,%xmm14
movapd %xmm13,%xmm1
unpckhpd %xmm13,%xmm1
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
test   %bpl,%bpl
je     171d <check_rotation+0x60d>
movapd %xmm14,%xmm1
movapd %xmm14,%xmm3
unpcklpd %xmm13,%xmm3
movsd  %xmm4,%xmm13
unpckhpd %xmm4,%xmm1
movapd %xmm11,%xmm0
movapd %xmm3,%xmm14
movapd %xmm13,%xmm4
movapd %xmm1,%xmm13
jmp    1760 <check_rotation+0x650>
cmp    $0x2,%r14d
jne    1756 <check_rotation+0x646>
shufpd $0x2,%xmm14,%xmm13
shufpd $0x2,%xmm4,%xmm1
movapd %xmm14,%xmm3
unpcklpd %xmm4,%xmm3
movapd %xmm10,%xmm0
movapd %xmm12,%xmm10
movapd %xmm11,%xmm12
movapd %xmm13,%xmm14
movapd %xmm1,%xmm4
movapd %xmm3,%xmm13
jmp    1760 <check_rotation+0x650>
movapd %xmm10,%xmm0
movapd %xmm11,%xmm10
movapd 0x70(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm12,%xmm1
movapd %xmm0,%xmm5
movapd 0xb0(%rsp),%xmm9
mulsd  %xmm9,%xmm5
subsd  %xmm1,%xmm5
xor    %r14d,%r14d
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm5
movapd %xmm3,%xmm7
jne    179b <check_rotation+0x68b>
jnp    17b1 <check_rotation+0x6a1>
movapd 0xa0(%rsp),%xmm11
movapd %xmm10,%xmm3
xor    %ebp,%ebp
jmp    1865 <check_rotation+0x755>
movapd 0xa0(%rsp),%xmm5
movapd %xmm5,%xmm1
mulsd  %xmm12,%xmm1
movapd %xmm10,%xmm3
mulsd  %xmm9,%xmm3
subsd  %xmm1,%xmm3
movapd %xmm3,%xmm1
cmpneqsd %xmm8,%xmm1
movq   %xmm1,%rbp
mov    %ebp,%r14d
and    $0x1,%r14d
ucomisd %xmm8,%xmm3
movapd %xmm7,%xmm11
jne    17ff <check_rotation+0x6ef>
movapd %xmm7,%xmm11
jp     17ff <check_rotation+0x6ef>
movapd %xmm9,%xmm11
movapd %xmm5,%xmm2
jne    180f <check_rotation+0x6ff>
movapd %xmm5,%xmm2
jp     180f <check_rotation+0x6ff>
movapd %xmm7,%xmm2
jne    1818 <check_rotation+0x708>
jp     1818 <check_rotation+0x708>
movapd %xmm5,%xmm9
movapd %xmm0,%xmm3
jne    1829 <check_rotation+0x719>
movapd %xmm0,%xmm3
jp     1829 <check_rotation+0x719>
movapd %xmm12,%xmm3
movapd %xmm10,%xmm1
jne    183b <check_rotation+0x72b>
movapd %xmm10,%xmm1
jp     183b <check_rotation+0x72b>
movapd %xmm0,%xmm1
jne    1844 <check_rotation+0x734>
jp     1844 <check_rotation+0x734>
movapd %xmm10,%xmm12
add    $0x2,%ebp
movapd %xmm12,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm1,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm2,%xmm7
movapd %xmm1,%xmm0
ucomisd %xmm8,%xmm5
jne    1872 <check_rotation+0x762>
jnp    1c8e <check_rotation+0xb7e>
movapd %xmm11,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm12,%xmm1
mulsd  %xmm7,%xmm1
mulsd  %xmm3,%xmm7
subsd  %xmm2,%xmm7
divsd  %xmm5,%xmm7
movapd %xmm15,%xmm6
mulsd  %xmm0,%xmm6
divsd  %xmm5,%xmm6
mulsd  %xmm12,%xmm11
mulsd  %xmm9,%xmm3
subsd  %xmm11,%xmm3
mulsd  %xmm9,%xmm0
subsd  %xmm0,%xmm1
mulsd  %xmm12,%xmm15
unpcklpd %xmm3,%xmm15
movapd %xmm7,%xmm2
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm15
movapd %xmm15,%xmm10
unpckhpd %xmm15,%xmm10
movapd %xmm10,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm7,%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm0,%xmm3
addsd  0x71c(%rip),%xmm3
movapd %xmm15,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm7,%xmm5
mulsd  %xmm6,%xmm5
addsd  %xmm0,%xmm5
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
addsd  0x6f8(%rip),%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm5,%xmm7
mulsd  %xmm5,%xmm7
subsd  %xmm1,%xmm7
xorpd  %xmm0,%xmm0
ucomisd %xmm7,%xmm0
ja     1c8e <check_rotation+0xb7e>
movapd 0x6b2(%rip),%xmm1
xorpd  %xmm5,%xmm1
movapd %xmm1,0xa0(%rsp)
xorps  %xmm8,%xmm8
sqrtsd %xmm7,%xmm8
ucomisd %xmm0,%xmm7
movapd %xmm8,%xmm1
movapd %xmm2,0x70(%rsp)
movapd %xmm15,0x60(%rsp)
movapd %xmm4,0x50(%rsp)
movapd %xmm13,0x80(%rsp)
movapd %xmm14,0x40(%rsp)
movapd %xmm10,0x30(%rsp)
movapd %xmm6,0x20(%rsp)
movapd %xmm3,0x10(%rsp)
movapd %xmm5,0xb0(%rsp)
jae    1a1a <check_rotation+0x90a>
movapd %xmm7,%xmm0
movapd %xmm7,(%rsp)
movapd %xmm8,0x90(%rsp)
call   1030 <sqrt@plt>
movapd 0x90(%rsp),%xmm8
movapd (%rsp),%xmm7
movapd 0xb0(%rsp),%xmm5
movapd 0x10(%rsp),%xmm3
movapd 0x20(%rsp),%xmm6
movapd 0x30(%rsp),%xmm10
movapd 0x40(%rsp),%xmm14
movapd 0x80(%rsp),%xmm13
movapd 0x50(%rsp),%xmm4
movapd 0x60(%rsp),%xmm15
movapd 0x70(%rsp),%xmm2
movapd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm7
jae    1a7c <check_rotation+0x96c>
movapd %xmm7,%xmm0
movapd %xmm1,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm1
movapd 0xb0(%rsp),%xmm5
movapd 0x10(%rsp),%xmm3
movapd 0x20(%rsp),%xmm6
movapd 0x30(%rsp),%xmm10
movapd 0x40(%rsp),%xmm14
movapd 0x80(%rsp),%xmm13
movapd 0x50(%rsp),%xmm4
movapd 0x60(%rsp),%xmm15
movapd 0x70(%rsp),%xmm2
movapd %xmm0,%xmm8
unpcklpd 0xa0(%rsp),%xmm1
unpcklpd %xmm8,%xmm5
subpd  %xmm5,%xmm1
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm1
unpcklpd %xmm2,%xmm2
unpcklpd %xmm6,%xmm6
mulpd  %xmm1,%xmm2
addpd  %xmm6,%xmm2
unpcklpd %xmm15,%xmm15
mulpd  %xmm1,%xmm10
movapd %xmm1,%xmm9
movapd %xmm2,%xmm8
cmp    $0x2,%ebp
je     1ac9 <check_rotation+0x9b9>
movapd %xmm2,%xmm9
movapd %xmm1,%xmm8
addpd  %xmm15,%xmm10
test   %r14b,%r14b
je     1ae2 <check_rotation+0x9d2>
movapd %xmm2,%xmm9
movapd %xmm10,%xmm8
movapd %xmm1,%xmm10
movapd %xmm14,%xmm0
unpckhpd %xmm14,%xmm0
mulpd  %xmm10,%xmm0
movapd %xmm14,%xmm1
unpcklpd %xmm14,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm13,%xmm3
unpcklpd %xmm13,%xmm3
mulpd  %xmm8,%xmm3
addpd  %xmm1,%xmm3
xorpd  %xmm0,%xmm0
movapd %xmm3,%xmm1
cmpltpd %xmm0,%xmm1
movapd 0x4d4(%rip),%xmm6
movapd %xmm1,%xmm0
andnpd %xmm3,%xmm0
xorpd  %xmm6,%xmm3
andpd  %xmm1,%xmm3
orpd   %xmm0,%xmm3
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
movapd %xmm10,%xmm15
unpckhpd %xmm10,%xmm15
movapd %xmm15,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm10,%xmm0
movapd %xmm4,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm13,%xmm0
unpckhpd %xmm13,%xmm0
movapd %xmm0,%xmm7
mulsd  %xmm8,%xmm7
addsd  %xmm2,%xmm7
movapd %xmm7,%xmm2
xorpd  %xmm6,%xmm2
xorpd  %xmm11,%xmm11
movapd %xmm7,%xmm5
cmpltsd %xmm11,%xmm5
andpd  %xmm5,%xmm2
andnpd %xmm7,%xmm5
orpd   %xmm2,%xmm5
movapd %xmm9,%xmm2
unpckhpd %xmm9,%xmm2
movapd %xmm2,%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm1,%xmm7
movapd %xmm8,%xmm12
unpckhpd %xmm8,%xmm12
movapd %xmm12,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm7,%xmm1
xorpd  %xmm1,%xmm6
movapd %xmm1,%xmm7
cmpltsd %xmm11,%xmm7
andpd  %xmm7,%xmm6
andnpd %xmm1,%xmm7
orpd   %xmm6,%xmm7
pshufd $0xee,%xmm3,%xmm6
ucomisd %xmm3,%xmm6
jbe    1c12 <check_rotation+0xb02>
ucomisd %xmm3,%xmm5
jbe    1c2b <check_rotation+0xb1b>
ucomisd %xmm3,%xmm7
jbe    1c61 <check_rotation+0xb51>
movupd %xmm14,(%rbx)
movsd  %xmm13,0x10(%rbx)
jmp    1c79 <check_rotation+0xb69>
ucomisd %xmm6,%xmm5
jbe    1c2b <check_rotation+0xb1b>
ucomisd %xmm6,%xmm7
jbe    1c61 <check_rotation+0xb51>
movupd %xmm14,(%rbx)
movsd  %xmm13,0x10(%rbx)
jmp    1c6a <check_rotation+0xb5a>
ucomisd %xmm5,%xmm7
movupd %xmm4,(%rbx)
movsd  %xmm0,0x10(%rbx)
cmpltsd %xmm7,%xmm5
movapd %xmm5,%xmm0
andpd  %xmm9,%xmm0
andnpd %xmm2,%xmm5
orpd   %xmm0,%xmm5
ja     1c5a <check_rotation+0xb4a>
movapd %xmm15,%xmm10
movapd %xmm12,%xmm8
movapd %xmm5,%xmm9
jmp    1c79 <check_rotation+0xb69>
movupd %xmm4,(%rbx)
movsd  %xmm0,0x10(%rbx)
movapd %xmm2,%xmm9
movapd %xmm15,%xmm10
movapd %xmm12,%xmm8
movsd  %xmm9,0x18(%rbx)
movsd  %xmm10,0x20(%rbx)
movsd  %xmm8,0x28(%rbx)
xor    %r15d,%r15d
mov    %r15d,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @check_rotation([3 x double]* %0) {
%2 = alloca i32
%3 = alloca [3 x double]*
%4 = alloca [3 x double]
%5 = alloca [3 x double]
%6 = alloca [3 x double]
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca i32
store [3 x double]* %0, [3 x double]** %3
%35 = load [3 x double]*, [3 x double]** %3
%36 = getelementptr inbounds [3 x double], [3 x double]* %35, i64 0
%37 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 0
%38 = load double, double* %37
%39 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
store double %38, double* %39
%40 = load [3 x double]*, [3 x double]** %3
%41 = getelementptr inbounds [3 x double], [3 x double]* %40, i64 0
%42 = getelementptr inbounds [3 x double], [3 x double]* %41, i64 0, i64 1
%43 = load double, double* %42
%44 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
store double %43, double* %44
%45 = load [3 x double]*, [3 x double]** %3
%46 = getelementptr inbounds [3 x double], [3 x double]* %45, i64 0
%47 = getelementptr inbounds [3 x double], [3 x double]* %46, i64 0, i64 2
%48 = load double, double* %47
%49 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
store double %48, double* %49
%50 = load [3 x double]*, [3 x double]** %3
%51 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 1
%52 = getelementptr inbounds [3 x double], [3 x double]* %51, i64 0, i64 0
%53 = load double, double* %52
%54 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
store double %53, double* %54
%55 = load [3 x double]*, [3 x double]** %3
%56 = getelementptr inbounds [3 x double], [3 x double]* %55, i64 1
%57 = getelementptr inbounds [3 x double], [3 x double]* %56, i64 0, i64 1
%58 = load double, double* %57
%59 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
store double %58, double* %59
%60 = load [3 x double]*, [3 x double]** %3
%61 = getelementptr inbounds [3 x double], [3 x double]* %60, i64 1
%62 = getelementptr inbounds [3 x double], [3 x double]* %61, i64 0, i64 2
%63 = load double, double* %62
%64 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %63, double* %64
%65 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%66 = load double, double* %65
%67 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%68 = load double, double* %67
%69 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%70 = load double, double* %69
%71 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%72 = load double, double* %71
%73 = fmul double %70, %72
%74 = fneg double %73
%75 = call double @llvm.fmuladd.f64(double %66, double %68, double %74)
%76 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %75, double* %76
%77 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%78 = load double, double* %77
%79 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%80 = load double, double* %79
%81 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%82 = load double, double* %81
%83 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%84 = load double, double* %83
%85 = fmul double %82, %84
%86 = fneg double %85
%87 = call double @llvm.fmuladd.f64(double %78, double %80, double %86)
%88 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %87, double* %88
%89 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%90 = load double, double* %89
%91 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%92 = load double, double* %91
%93 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%94 = load double, double* %93
%95 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%96 = load double, double* %95
%97 = fmul double %94, %96
%98 = fneg double %97
%99 = call double @llvm.fmuladd.f64(double %90, double %92, double %98)
%100 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %99, double* %100
%101 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%102 = load double, double* %101
%103 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%104 = load double, double* %103
%105 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%106 = load double, double* %105
%107 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%108 = load double, double* %107
%109 = fmul double %106, %108
%110 = call double @llvm.fmuladd.f64(double %102, double %104, double %109)
%111 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%112 = load double, double* %111
%113 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%114 = load double, double* %113
%115 = call double @llvm.fmuladd.f64(double %112, double %114, double %110)
%116 = call double @sqrt(double %115)
store double %116, double* %29
%117 = load double, double* %29
%118 = fcmp oeq double %117, 0.000000e+00
br i1 %118, label %119, label %120
119: ; preds = %1
store i32 -1, i32* %2
br label %974
120: ; preds = %1
%121 = load double, double* %29
%122 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%123 = load double, double* %122
%124 = fdiv double %123, %121
store double %124, double* %122
%125 = load double, double* %29
%126 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%127 = load double, double* %126
%128 = fdiv double %127, %125
store double %128, double* %126
%129 = load double, double* %29
%130 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%131 = load double, double* %130
%132 = fdiv double %131, %129
store double %132, double* %130
%133 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%134 = load double, double* %133
%135 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%136 = load double, double* %135
%137 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%138 = load double, double* %137
%139 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%140 = load double, double* %139
%141 = fmul double %138, %140
%142 = call double @llvm.fmuladd.f64(double %134, double %136, double %141)
%143 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%144 = load double, double* %143
%145 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%146 = load double, double* %145
%147 = call double @llvm.fmuladd.f64(double %144, double %146, double %142)
store double %147, double* %8
%148 = load double, double* %8
%149 = fcmp olt double %148, 0.000000e+00
br i1 %149, label %150, label %153
150: ; preds = %120
%151 = load double, double* %8
%152 = fmul double %151, -1.000000e+00
store double %152, double* %8
br label %153
153: ; preds = %150, %120
%154 = load double, double* %8
%155 = fadd double %154, 1.000000e+00
%156 = call double @sqrt(double %155)
%157 = load double, double* %8
%158 = fsub double 1.000000e+00, %157
%159 = call double @sqrt(double %158)
%160 = fadd double %156, %159
%161 = fmul double %160, 5.000000e-01
store double %161, double* %7
%162 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%163 = load double, double* %162
%164 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%165 = load double, double* %164
%166 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%167 = load double, double* %166
%168 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%169 = load double, double* %168
%170 = fmul double %167, %169
%171 = fneg double %170
%172 = call double @llvm.fmuladd.f64(double %163, double %165, double %171)
%173 = fcmp une double %172, 0.000000e+00
br i1 %173, label %174, label %175
174: ; preds = %153
store i32 0, i32* %34
br label %219
175: ; preds = %153
%176 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%177 = load double, double* %176
%178 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%179 = load double, double* %178
%180 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%181 = load double, double* %180
%182 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%183 = load double, double* %182
%184 = fmul double %181, %183
%185 = fneg double %184
%186 = call double @llvm.fmuladd.f64(double %177, double %179, double %185)
%187 = fcmp une double %186, 0.000000e+00
br i1 %187, label %188, label %203
188: ; preds = %175
%189 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%190 = load double, double* %189
store double %190, double* %29
%191 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%192 = load double, double* %191
%193 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
store double %192, double* %193
%194 = load double, double* %29
%195 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
store double %194, double* %195
%196 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%197 = load double, double* %196
store double %197, double* %29
%198 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%199 = load double, double* %198
%200 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %199, double* %200
%201 = load double, double* %29
%202 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %201, double* %202
store i32 1, i32* %34
br label %218
203: ; preds = %175
%204 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%205 = load double, double* %204
store double %205, double* %29
%206 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%207 = load double, double* %206
%208 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
store double %207, double* %208
%209 = load double, double* %29
%210 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
store double %209, double* %210
%211 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%212 = load double, double* %211
store double %212, double* %29
%213 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%214 = load double, double* %213
%215 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %214, double* %215
%216 = load double, double* %29
%217 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %216, double* %217
store i32 2, i32* %34
br label %218
218: ; preds = %203, %188
br label %219
219: ; preds = %218, %174
%220 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%221 = load double, double* %220
%222 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%223 = load double, double* %222
%224 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%225 = load double, double* %224
%226 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%227 = load double, double* %226
%228 = fmul double %225, %227
%229 = fneg double %228
%230 = call double @llvm.fmuladd.f64(double %221, double %223, double %229)
%231 = fcmp oeq double %230, 0.000000e+00
br i1 %231, label %232, label %233
232: ; preds = %219
store i32 -1, i32* %2
br label %974
233: ; preds = %219
%234 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%235 = load double, double* %234
%236 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%237 = load double, double* %236
%238 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%239 = load double, double* %238
%240 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%241 = load double, double* %240
%242 = fmul double %239, %241
%243 = fneg double %242
%244 = call double @llvm.fmuladd.f64(double %235, double %237, double %243)
%245 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%246 = load double, double* %245
%247 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%248 = load double, double* %247
%249 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%250 = load double, double* %249
%251 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%252 = load double, double* %251
%253 = fmul double %250, %252
%254 = fneg double %253
%255 = call double @llvm.fmuladd.f64(double %246, double %248, double %254)
%256 = fdiv double %244, %255
store double %256, double* %9
%257 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%258 = load double, double* %257
%259 = load double, double* %7
%260 = fmul double %258, %259
%261 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%262 = load double, double* %261
%263 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%264 = load double, double* %263
%265 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%266 = load double, double* %265
%267 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%268 = load double, double* %267
%269 = fmul double %266, %268
%270 = fneg double %269
%271 = call double @llvm.fmuladd.f64(double %262, double %264, double %270)
%272 = fdiv double %260, %271
store double %272, double* %10
%273 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%274 = load double, double* %273
%275 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%276 = load double, double* %275
%277 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%278 = load double, double* %277
%279 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%280 = load double, double* %279
%281 = fmul double %278, %280
%282 = fneg double %281
%283 = call double @llvm.fmuladd.f64(double %274, double %276, double %282)
%284 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%285 = load double, double* %284
%286 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%287 = load double, double* %286
%288 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%289 = load double, double* %288
%290 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%291 = load double, double* %290
%292 = fmul double %289, %291
%293 = fneg double %292
%294 = call double @llvm.fmuladd.f64(double %285, double %287, double %293)
%295 = fdiv double %283, %294
store double %295, double* %11
%296 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%297 = load double, double* %296
%298 = load double, double* %7
%299 = fmul double %297, %298
%300 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%301 = load double, double* %300
%302 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%303 = load double, double* %302
%304 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%305 = load double, double* %304
%306 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%307 = load double, double* %306
%308 = fmul double %305, %307
%309 = fneg double %308
%310 = call double @llvm.fmuladd.f64(double %301, double %303, double %309)
%311 = fdiv double %299, %310
store double %311, double* %12
%312 = load double, double* %9
%313 = load double, double* %9
%314 = load double, double* %11
%315 = load double, double* %11
%316 = fmul double %314, %315
%317 = call double @llvm.fmuladd.f64(double %312, double %313, double %316)
%318 = fadd double %317, 1.000000e+00
store double %318, double* %13
%319 = load double, double* %9
%320 = load double, double* %10
%321 = load double, double* %11
%322 = load double, double* %12
%323 = fmul double %321, %322
%324 = call double @llvm.fmuladd.f64(double %319, double %320, double %323)
store double %324, double* %14
%325 = load double, double* %10
%326 = load double, double* %10
%327 = load double, double* %12
%328 = load double, double* %12
%329 = fmul double %327, %328
%330 = call double @llvm.fmuladd.f64(double %325, double %326, double %329)
%331 = fsub double %330, 1.000000e+00
store double %331, double* %15
%332 = load double, double* %14
%333 = load double, double* %14
%334 = load double, double* %13
%335 = load double, double* %15
%336 = fmul double %334, %335
%337 = fneg double %336
%338 = call double @llvm.fmuladd.f64(double %332, double %333, double %337)
store double %338, double* %16
%339 = load double, double* %16
%340 = fcmp olt double %339, 0.000000e+00
br i1 %340, label %341, label %342
341: ; preds = %233
store i32 -1, i32* %2
br label %974
342: ; preds = %233
%343 = load double, double* %14
%344 = fneg double %343
%345 = load double, double* %16
%346 = call double @sqrt(double %345)
%347 = fadd double %344, %346
%348 = load double, double* %13
%349 = fdiv double %347, %348
store double %349, double* %19
%350 = load double, double* %9
%351 = load double, double* %19
%352 = load double, double* %10
%353 = call double @llvm.fmuladd.f64(double %350, double %351, double %352)
store double %353, double* %17
%354 = load double, double* %11
%355 = load double, double* %19
%356 = load double, double* %12
%357 = call double @llvm.fmuladd.f64(double %354, double %355, double %356)
store double %357, double* %18
%358 = load double, double* %14
%359 = fneg double %358
%360 = load double, double* %16
%361 = call double @sqrt(double %360)
%362 = fsub double %359, %361
%363 = load double, double* %13
%364 = fdiv double %362, %363
store double %364, double* %22
%365 = load double, double* %9
%366 = load double, double* %22
%367 = load double, double* %10
%368 = call double @llvm.fmuladd.f64(double %365, double %366, double %367)
store double %368, double* %20
%369 = load double, double* %11
%370 = load double, double* %22
%371 = load double, double* %12
%372 = call double @llvm.fmuladd.f64(double %369, double %370, double %371)
store double %372, double* %21
%373 = load i32, i32* %34
%374 = icmp eq i32 %373, 1
br i1 %374, label %375, label %396
375: ; preds = %342
%376 = load double, double* %18
store double %376, double* %29
%377 = load double, double* %19
store double %377, double* %18
%378 = load double, double* %29
store double %378, double* %19
%379 = load double, double* %21
store double %379, double* %29
%380 = load double, double* %22
store double %380, double* %21
%381 = load double, double* %29
store double %381, double* %22
%382 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%383 = load double, double* %382
store double %383, double* %29
%384 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%385 = load double, double* %384
%386 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
store double %385, double* %386
%387 = load double, double* %29
%388 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
store double %387, double* %388
%389 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%390 = load double, double* %389
store double %390, double* %29
%391 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%392 = load double, double* %391
%393 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %392, double* %393
%394 = load double, double* %29
%395 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %394, double* %395
store i32 0, i32* %34
br label %396
396: ; preds = %375, %342
%397 = load i32, i32* %34
%398 = icmp eq i32 %397, 2
br i1 %398, label %399, label %420
399: ; preds = %396
%400 = load double, double* %17
store double %400, double* %29
%401 = load double, double* %19
store double %401, double* %17
%402 = load double, double* %29
store double %402, double* %19
%403 = load double, double* %20
store double %403, double* %29
%404 = load double, double* %22
store double %404, double* %20
%405 = load double, double* %29
store double %405, double* %22
%406 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%407 = load double, double* %406
store double %407, double* %29
%408 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%409 = load double, double* %408
%410 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
store double %409, double* %410
%411 = load double, double* %29
%412 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
store double %411, double* %412
%413 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%414 = load double, double* %413
store double %414, double* %29
%415 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%416 = load double, double* %415
%417 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %416, double* %417
%418 = load double, double* %29
%419 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %418, double* %419
store i32 0, i32* %34
br label %420
420: ; preds = %399, %396
%421 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%422 = load double, double* %421
%423 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%424 = load double, double* %423
%425 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%426 = load double, double* %425
%427 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%428 = load double, double* %427
%429 = fmul double %426, %428
%430 = fneg double %429
%431 = call double @llvm.fmuladd.f64(double %422, double %424, double %430)
%432 = fcmp une double %431, 0.000000e+00
br i1 %432, label %433, label %434
433: ; preds = %420
store i32 0, i32* %34
br label %478
434: ; preds = %420
%435 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%436 = load double, double* %435
%437 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%438 = load double, double* %437
%439 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%440 = load double, double* %439
%441 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%442 = load double, double* %441
%443 = fmul double %440, %442
%444 = fneg double %443
%445 = call double @llvm.fmuladd.f64(double %436, double %438, double %444)
%446 = fcmp une double %445, 0.000000e+00
br i1 %446, label %447, label %462
447: ; preds = %434
%448 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%449 = load double, double* %448
store double %449, double* %29
%450 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%451 = load double, double* %450
%452 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
store double %451, double* %452
%453 = load double, double* %29
%454 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %453, double* %454
%455 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%456 = load double, double* %455
store double %456, double* %29
%457 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%458 = load double, double* %457
%459 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %458, double* %459
%460 = load double, double* %29
%461 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %460, double* %461
store i32 1, i32* %34
br label %477
462: ; preds = %434
%463 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%464 = load double, double* %463
store double %464, double* %29
%465 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%466 = load double, double* %465
%467 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
store double %466, double* %467
%468 = load double, double* %29
%469 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %468, double* %469
%470 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%471 = load double, double* %470
store double %471, double* %29
%472 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%473 = load double, double* %472
%474 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %473, double* %474
%475 = load double, double* %29
%476 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %475, double* %476
store i32 2, i32* %34
br label %477
477: ; preds = %462, %447
br label %478
478: ; preds = %477, %433
%479 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%480 = load double, double* %479
%481 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%482 = load double, double* %481
%483 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%484 = load double, double* %483
%485 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%486 = load double, double* %485
%487 = fmul double %484, %486
%488 = fneg double %487
%489 = call double @llvm.fmuladd.f64(double %480, double %482, double %488)
%490 = fcmp oeq double %489, 0.000000e+00
br i1 %490, label %491, label %492
491: ; preds = %478
store i32 -1, i32* %2
br label %974
492: ; preds = %478
%493 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%494 = load double, double* %493
%495 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%496 = load double, double* %495
%497 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%498 = load double, double* %497
%499 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%500 = load double, double* %499
%501 = fmul double %498, %500
%502 = fneg double %501
%503 = call double @llvm.fmuladd.f64(double %494, double %496, double %502)
%504 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%505 = load double, double* %504
%506 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%507 = load double, double* %506
%508 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%509 = load double, double* %508
%510 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%511 = load double, double* %510
%512 = fmul double %509, %511
%513 = fneg double %512
%514 = call double @llvm.fmuladd.f64(double %505, double %507, double %513)
%515 = fdiv double %503, %514
store double %515, double* %9
%516 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%517 = load double, double* %516
%518 = load double, double* %7
%519 = fmul double %517, %518
%520 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%521 = load double, double* %520
%522 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%523 = load double, double* %522
%524 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%525 = load double, double* %524
%526 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%527 = load double, double* %526
%528 = fmul double %525, %527
%529 = fneg double %528
%530 = call double @llvm.fmuladd.f64(double %521, double %523, double %529)
%531 = fdiv double %519, %530
store double %531, double* %10
%532 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%533 = load double, double* %532
%534 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%535 = load double, double* %534
%536 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%537 = load double, double* %536
%538 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%539 = load double, double* %538
%540 = fmul double %537, %539
%541 = fneg double %540
%542 = call double @llvm.fmuladd.f64(double %533, double %535, double %541)
%543 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%544 = load double, double* %543
%545 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%546 = load double, double* %545
%547 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%548 = load double, double* %547
%549 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%550 = load double, double* %549
%551 = fmul double %548, %550
%552 = fneg double %551
%553 = call double @llvm.fmuladd.f64(double %544, double %546, double %552)
%554 = fdiv double %542, %553
store double %554, double* %11
%555 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%556 = load double, double* %555
%557 = load double, double* %7
%558 = fmul double %556, %557
%559 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%560 = load double, double* %559
%561 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%562 = load double, double* %561
%563 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%564 = load double, double* %563
%565 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%566 = load double, double* %565
%567 = fmul double %564, %566
%568 = fneg double %567
%569 = call double @llvm.fmuladd.f64(double %560, double %562, double %568)
%570 = fdiv double %558, %569
store double %570, double* %12
%571 = load double, double* %9
%572 = load double, double* %9
%573 = load double, double* %11
%574 = load double, double* %11
%575 = fmul double %573, %574
%576 = call double @llvm.fmuladd.f64(double %571, double %572, double %575)
%577 = fadd double %576, 1.000000e+00
store double %577, double* %13
%578 = load double, double* %9
%579 = load double, double* %10
%580 = load double, double* %11
%581 = load double, double* %12
%582 = fmul double %580, %581
%583 = call double @llvm.fmuladd.f64(double %578, double %579, double %582)
store double %583, double* %14
%584 = load double, double* %10
%585 = load double, double* %10
%586 = load double, double* %12
%587 = load double, double* %12
%588 = fmul double %586, %587
%589 = call double @llvm.fmuladd.f64(double %584, double %585, double %588)
%590 = fsub double %589, 1.000000e+00
store double %590, double* %15
%591 = load double, double* %14
%592 = load double, double* %14
%593 = load double, double* %13
%594 = load double, double* %15
%595 = fmul double %593, %594
%596 = fneg double %595
%597 = call double @llvm.fmuladd.f64(double %591, double %592, double %596)
store double %597, double* %16
%598 = load double, double* %16
%599 = fcmp olt double %598, 0.000000e+00
br i1 %599, label %600, label %601
600: ; preds = %492
store i32 -1, i32* %2
br label %974
601: ; preds = %492
%602 = load double, double* %14
%603 = fneg double %602
%604 = load double, double* %16
%605 = call double @sqrt(double %604)
%606 = fadd double %603, %605
%607 = load double, double* %13
%608 = fdiv double %606, %607
store double %608, double* %25
%609 = load double, double* %9
%610 = load double, double* %25
%611 = load double, double* %10
%612 = call double @llvm.fmuladd.f64(double %609, double %610, double %611)
store double %612, double* %23
%613 = load double, double* %11
%614 = load double, double* %25
%615 = load double, double* %12
%616 = call double @llvm.fmuladd.f64(double %613, double %614, double %615)
store double %616, double* %24
%617 = load double, double* %14
%618 = fneg double %617
%619 = load double, double* %16
%620 = call double @sqrt(double %619)
%621 = fsub double %618, %620
%622 = load double, double* %13
%623 = fdiv double %621, %622
store double %623, double* %28
%624 = load double, double* %9
%625 = load double, double* %28
%626 = load double, double* %10
%627 = call double @llvm.fmuladd.f64(double %624, double %625, double %626)
store double %627, double* %26
%628 = load double, double* %11
%629 = load double, double* %28
%630 = load double, double* %12
%631 = call double @llvm.fmuladd.f64(double %628, double %629, double %630)
store double %631, double* %27
%632 = load i32, i32* %34
%633 = icmp eq i32 %632, 1
br i1 %633, label %634, label %655
634: ; preds = %601
%635 = load double, double* %24
store double %635, double* %29
%636 = load double, double* %25
store double %636, double* %24
%637 = load double, double* %29
store double %637, double* %25
%638 = load double, double* %27
store double %638, double* %29
%639 = load double, double* %28
store double %639, double* %27
%640 = load double, double* %29
store double %640, double* %28
%641 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
%642 = load double, double* %641
store double %642, double* %29
%643 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%644 = load double, double* %643
%645 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 1
store double %644, double* %645
%646 = load double, double* %29
%647 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %646, double* %647
%648 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%649 = load double, double* %648
store double %649, double* %29
%650 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%651 = load double, double* %650
%652 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
store double %651, double* %652
%653 = load double, double* %29
%654 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %653, double* %654
store i32 0, i32* %34
br label %655
655: ; preds = %634, %601
%656 = load i32, i32* %34
%657 = icmp eq i32 %656, 2
br i1 %657, label %658, label %679
658: ; preds = %655
%659 = load double, double* %23
store double %659, double* %29
%660 = load double, double* %25
store double %660, double* %23
%661 = load double, double* %29
store double %661, double* %25
%662 = load double, double* %26
store double %662, double* %29
%663 = load double, double* %28
store double %663, double* %26
%664 = load double, double* %29
store double %664, double* %28
%665 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
%666 = load double, double* %665
store double %666, double* %29
%667 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
%668 = load double, double* %667
%669 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 0
store double %668, double* %669
%670 = load double, double* %29
%671 = getelementptr inbounds [3 x double], [3 x double]* %5, i64 0, i64 2
store double %670, double* %671
%672 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%673 = load double, double* %672
store double %673, double* %29
%674 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
%675 = load double, double* %674
%676 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
store double %675, double* %676
%677 = load double, double* %29
%678 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %677, double* %678
store i32 0, i32* %34
br label %679
679: ; preds = %658, %655
%680 = load double, double* %17
%681 = load double, double* %23
%682 = load double, double* %18
%683 = load double, double* %24
%684 = fmul double %682, %683
%685 = call double @llvm.fmuladd.f64(double %680, double %681, double %684)
%686 = load double, double* %19
%687 = load double, double* %25
%688 = call double @llvm.fmuladd.f64(double %686, double %687, double %685)
store double %688, double* %30
%689 = load double, double* %30
%690 = fcmp olt double %689, 0.000000e+00
br i1 %690, label %691, label %694
691: ; preds = %679
%692 = load double, double* %30
%693 = fneg double %692
store double %693, double* %30
br label %694
694: ; preds = %691, %679
%695 = load double, double* %17
%696 = load double, double* %26
%697 = load double, double* %18
%698 = load double, double* %27
%699 = fmul double %697, %698
%700 = call double @llvm.fmuladd.f64(double %695, double %696, double %699)
%701 = load double, double* %19
%702 = load double, double* %28
%703 = call double @llvm.fmuladd.f64(double %701, double %702, double %700)
store double %703, double* %31
%704 = load double, double* %31
%705 = fcmp olt double %704, 0.000000e+00
br i1 %705, label %706, label %709
706: ; preds = %694
%707 = load double, double* %31
%708 = fneg double %707
store double %708, double* %31
br label %709
709: ; preds = %706, %694
%710 = load double, double* %20
%711 = load double, double* %23
%712 = load double, double* %21
%713 = load double, double* %24
%714 = fmul double %712, %713
%715 = call double @llvm.fmuladd.f64(double %710, double %711, double %714)
%716 = load double, double* %22
%717 = load double, double* %25
%718 = call double @llvm.fmuladd.f64(double %716, double %717, double %715)
store double %718, double* %32
%719 = load double, double* %32
%720 = fcmp olt double %719, 0.000000e+00
br i1 %720, label %721, label %724
721: ; preds = %709
%722 = load double, double* %32
%723 = fneg double %722
store double %723, double* %32
br label %724
724: ; preds = %721, %709
%725 = load double, double* %20
%726 = load double, double* %26
%727 = load double, double* %21
%728 = load double, double* %27
%729 = fmul double %727, %728
%730 = call double @llvm.fmuladd.f64(double %725, double %726, double %729)
%731 = load double, double* %22
%732 = load double, double* %28
%733 = call double @llvm.fmuladd.f64(double %731, double %732, double %730)
store double %733, double* %33
%734 = load double, double* %33
%735 = fcmp olt double %734, 0.000000e+00
br i1 %735, label %736, label %739
736: ; preds = %724
%737 = load double, double* %33
%738 = fneg double %737
store double %738, double* %33
br label %739
739: ; preds = %736, %724
%740 = load double, double* %30
%741 = load double, double* %31
%742 = fcmp olt double %740, %741
br i1 %742, label %743, label %858
743: ; preds = %739
%744 = load double, double* %30
%745 = load double, double* %32
%746 = fcmp olt double %744, %745
br i1 %746, label %747, label %802
747: ; preds = %743
%748 = load double, double* %30
%749 = load double, double* %33
%750 = fcmp olt double %748, %749
br i1 %750, label %751, label %776
751: ; preds = %747
%752 = load double, double* %17
%753 = load [3 x double]*, [3 x double]** %3
%754 = getelementptr inbounds [3 x double], [3 x double]* %753, i64 0
%755 = getelementptr inbounds [3 x double], [3 x double]* %754, i64 0, i64 0
store double %752, double* %755
%756 = load double, double* %18
%757 = load [3 x double]*, [3 x double]** %3
%758 = getelementptr inbounds [3 x double], [3 x double]* %757, i64 0
%759 = getelementptr inbounds [3 x double], [3 x double]* %758, i64 0, i64 1
store double %756, double* %759
%760 = load double, double* %19
%761 = load [3 x double]*, [3 x double]** %3
%762 = getelementptr inbounds [3 x double], [3 x double]* %761, i64 0
%763 = getelementptr inbounds [3 x double], [3 x double]* %762, i64 0, i64 2
store double %760, double* %763
%764 = load double, double* %23
%765 = load [3 x double]*, [3 x double]** %3
%766 = getelementptr inbounds [3 x double], [3 x double]* %765, i64 1
%767 = getelementptr inbounds [3 x double], [3 x double]* %766, i64 0, i64 0
store double %764, double* %767
%768 = load double, double* %24
%769 = load [3 x double]*, [3 x double]** %3
%770 = getelementptr inbounds [3 x double], [3 x double]* %769, i64 1
%771 = getelementptr inbounds [3 x double], [3 x double]* %770, i64 0, i64 1
store double %768, double* %771
%772 = load double, double* %25
%773 = load [3 x double]*, [3 x double]** %3
%774 = getelementptr inbounds [3 x double], [3 x double]* %773, i64 1
%775 = getelementptr inbounds [3 x double], [3 x double]* %774, i64 0, i64 2
store double %772, double* %775
br label %801
776: ; preds = %747
%777 = load double, double* %20
%778 = load [3 x double]*, [3 x double]** %3
%779 = getelementptr inbounds [3 x double], [3 x double]* %778, i64 0
%780 = getelementptr inbounds [3 x double], [3 x double]* %779, i64 0, i64 0
store double %777, double* %780
%781 = load double, double* %21
%782 = load [3 x double]*, [3 x double]** %3
%783 = getelementptr inbounds [3 x double], [3 x double]* %782, i64 0
%784 = getelementptr inbounds [3 x double], [3 x double]* %783, i64 0, i64 1
store double %781, double* %784
%785 = load double, double* %22
%786 = load [3 x double]*, [3 x double]** %3
%787 = getelementptr inbounds [3 x double], [3 x double]* %786, i64 0
%788 = getelementptr inbounds [3 x double], [3 x double]* %787, i64 0, i64 2
store double %785, double* %788
%789 = load double, double* %26
%790 = load [3 x double]*, [3 x double]** %3
%791 = getelementptr inbounds [3 x double], [3 x double]* %790, i64 1
%792 = getelementptr inbounds [3 x double], [3 x double]* %791, i64 0, i64 0
store double %789, double* %792
%793 = load double, double* %27
%794 = load [3 x double]*, [3 x double]** %3
%795 = getelementptr inbounds [3 x double], [3 x double]* %794, i64 1
%796 = getelementptr inbounds [3 x double], [3 x double]* %795, i64 0, i64 1
store double %793, double* %796
%797 = load double, double* %28
%798 = load [3 x double]*, [3 x double]** %3
%799 = getelementptr inbounds [3 x double], [3 x double]* %798, i64 1
%800 = getelementptr inbounds [3 x double], [3 x double]* %799, i64 0, i64 2
store double %797, double* %800
br label %801
801: ; preds = %776, %751
br label %857
802: ; preds = %743
%803 = load double, double* %32
%804 = load double, double* %33
%805 = fcmp olt double %803, %804
br i1 %805, label %806, label %831
806: ; preds = %802
%807 = load double, double* %20
%808 = load [3 x double]*, [3 x double]** %3
%809 = getelementptr inbounds [3 x double], [3 x double]* %808, i64 0
%810 = getelementptr inbounds [3 x double], [3 x double]* %809, i64 0, i64 0
store double %807, double* %810
%811 = load double, double* %21
%812 = load [3 x double]*, [3 x double]** %3
%813 = getelementptr inbounds [3 x double], [3 x double]* %812, i64 0
%814 = getelementptr inbounds [3 x double], [3 x double]* %813, i64 0, i64 1
store double %811, double* %814
%815 = load double, double* %22
%816 = load [3 x double]*, [3 x double]** %3
%817 = getelementptr inbounds [3 x double], [3 x double]* %816, i64 0
%818 = getelementptr inbounds [3 x double], [3 x double]* %817, i64 0, i64 2
store double %815, double* %818
%819 = load double, double* %23
%820 = load [3 x double]*, [3 x double]** %3
%821 = getelementptr inbounds [3 x double], [3 x double]* %820, i64 1
%822 = getelementptr inbounds [3 x double], [3 x double]* %821, i64 0, i64 0
store double %819, double* %822
%823 = load double, double* %24
%824 = load [3 x double]*, [3 x double]** %3
%825 = getelementptr inbounds [3 x double], [3 x double]* %824, i64 1
%826 = getelementptr inbounds [3 x double], [3 x double]* %825, i64 0, i64 1
store double %823, double* %826
%827 = load double, double* %25
%828 = load [3 x double]*, [3 x double]** %3
%829 = getelementptr inbounds [3 x double], [3 x double]* %828, i64 1
%830 = getelementptr inbounds [3 x double], [3 x double]* %829, i64 0, i64 2
store double %827, double* %830
br label %856
831: ; preds = %802
%832 = load double, double* %20
%833 = load [3 x double]*, [3 x double]** %3
%834 = getelementptr inbounds [3 x double], [3 x double]* %833, i64 0
%835 = getelementptr inbounds [3 x double], [3 x double]* %834, i64 0, i64 0
store double %832, double* %835
%836 = load double, double* %21
%837 = load [3 x double]*, [3 x double]** %3
%838 = getelementptr inbounds [3 x double], [3 x double]* %837, i64 0
%839 = getelementptr inbounds [3 x double], [3 x double]* %838, i64 0, i64 1
store double %836, double* %839
%840 = load double, double* %22
%841 = load [3 x double]*, [3 x double]** %3
%842 = getelementptr inbounds [3 x double], [3 x double]* %841, i64 0
%843 = getelementptr inbounds [3 x double], [3 x double]* %842, i64 0, i64 2
store double %840, double* %843
%844 = load double, double* %26
%845 = load [3 x double]*, [3 x double]** %3
%846 = getelementptr inbounds [3 x double], [3 x double]* %845, i64 1
%847 = getelementptr inbounds [3 x double], [3 x double]* %846, i64 0, i64 0
store double %844, double* %847
%848 = load double, double* %27
%849 = load [3 x double]*, [3 x double]** %3
%850 = getelementptr inbounds [3 x double], [3 x double]* %849, i64 1
%851 = getelementptr inbounds [3 x double], [3 x double]* %850, i64 0, i64 1
store double %848, double* %851
%852 = load double, double* %28
%853 = load [3 x double]*, [3 x double]** %3
%854 = getelementptr inbounds [3 x double], [3 x double]* %853, i64 1
%855 = getelementptr inbounds [3 x double], [3 x double]* %854, i64 0, i64 2
store double %852, double* %855
br label %856
856: ; preds = %831, %806
br label %857
857: ; preds = %856, %801
br label %973
858: ; preds = %739
%859 = load double, double* %31
%860 = load double, double* %32
%861 = fcmp olt double %859, %860
br i1 %861, label %862, label %917
862: ; preds = %858
%863 = load double, double* %31
%864 = load double, double* %33
%865 = fcmp olt double %863, %864
br i1 %865, label %866, label %891
866: ; preds = %862
%867 = load double, double* %17
%868 = load [3 x double]*, [3 x double]** %3
%869 = getelementptr inbounds [3 x double], [3 x double]* %868, i64 0
%870 = getelementptr inbounds [3 x double], [3 x double]* %869, i64 0, i64 0
store double %867, double* %870
%871 = load double, double* %18
%872 = load [3 x double]*, [3 x double]** %3
%873 = getelementptr inbounds [3 x double], [3 x double]* %872, i64 0
%874 = getelementptr inbounds [3 x double], [3 x double]* %873, i64 0, i64 1
store double %871, double* %874
%875 = load double, double* %19
%876 = load [3 x double]*, [3 x double]** %3
%877 = getelementptr inbounds [3 x double], [3 x double]* %876, i64 0
%878 = getelementptr inbounds [3 x double], [3 x double]* %877, i64 0, i64 2
store double %875, double* %878
%879 = load double, double* %26
%880 = load [3 x double]*, [3 x double]** %3
%881 = getelementptr inbounds [3 x double], [3 x double]* %880, i64 1
%882 = getelementptr inbounds [3 x double], [3 x double]* %881, i64 0, i64 0
store double %879, double* %882
%883 = load double, double* %27
%884 = load [3 x double]*, [3 x double]** %3
%885 = getelementptr inbounds [3 x double], [3 x double]* %884, i64 1
%886 = getelementptr inbounds [3 x double], [3 x double]* %885, i64 0, i64 1
store double %883, double* %886
%887 = load double, double* %28
%888 = load [3 x double]*, [3 x double]** %3
%889 = getelementptr inbounds [3 x double], [3 x double]* %888, i64 1
%890 = getelementptr inbounds [3 x double], [3 x double]* %889, i64 0, i64 2
store double %887, double* %890
br label %916
891: ; preds = %862
%892 = load double, double* %20
%893 = load [3 x double]*, [3 x double]** %3
%894 = getelementptr inbounds [3 x double], [3 x double]* %893, i64 0
%895 = getelementptr inbounds [3 x double], [3 x double]* %894, i64 0, i64 0
store double %892, double* %895
%896 = load double, double* %21
%897 = load [3 x double]*, [3 x double]** %3
%898 = getelementptr inbounds [3 x double], [3 x double]* %897, i64 0
%899 = getelementptr inbounds [3 x double], [3 x double]* %898, i64 0, i64 1
store double %896, double* %899
%900 = load double, double* %22
%901 = load [3 x double]*, [3 x double]** %3
%902 = getelementptr inbounds [3 x double], [3 x double]* %901, i64 0
%903 = getelementptr inbounds [3 x double], [3 x double]* %902, i64 0, i64 2
store double %900, double* %903
%904 = load double, double* %26
%905 = load [3 x double]*, [3 x double]** %3
%906 = getelementptr inbounds [3 x double], [3 x double]* %905, i64 1
%907 = getelementptr inbounds [3 x double], [3 x double]* %906, i64 0, i64 0
store double %904, double* %907
%908 = load double, double* %27
%909 = load [3 x double]*, [3 x double]** %3
%910 = getelementptr inbounds [3 x double], [3 x double]* %909, i64 1
%911 = getelementptr inbounds [3 x double], [3 x double]* %910, i64 0, i64 1
store double %908, double* %911
%912 = load double, double* %28
%913 = load [3 x double]*, [3 x double]** %3
%914 = getelementptr inbounds [3 x double], [3 x double]* %913, i64 1
%915 = getelementptr inbounds [3 x double], [3 x double]* %914, i64 0, i64 2
store double %912, double* %915
br label %916
916: ; preds = %891, %866
br label %972
917: ; preds = %858
%918 = load double, double* %32
%919 = load double, double* %33
%920 = fcmp olt double %918, %919
br i1 %920, label %921, label %946
921: ; preds = %917
%922 = load double, double* %20
%923 = load [3 x double]*, [3 x double]** %3
%924 = getelementptr inbounds [3 x double], [3 x double]* %923, i64 0
%925 = getelementptr inbounds [3 x double], [3 x double]* %924, i64 0, i64 0
store double %922, double* %925
%926 = load double, double* %21
%927 = load [3 x double]*, [3 x double]** %3
%928 = getelementptr inbounds [3 x double], [3 x double]* %927, i64 0
%929 = getelementptr inbounds [3 x double], [3 x double]* %928, i64 0, i64 1
store double %926, double* %929
%930 = load double, double* %22
%931 = load [3 x double]*, [3 x double]** %3
%932 = getelementptr inbounds [3 x double], [3 x double]* %931, i64 0
%933 = getelementptr inbounds [3 x double], [3 x double]* %932, i64 0, i64 2
store double %930, double* %933
%934 = load double, double* %23
%935 = load [3 x double]*, [3 x double]** %3
%936 = getelementptr inbounds [3 x double], [3 x double]* %935, i64 1
%937 = getelementptr inbounds [3 x double], [3 x double]* %936, i64 0, i64 0
store double %934, double* %937
%938 = load double, double* %24
%939 = load [3 x double]*, [3 x double]** %3
%940 = getelementptr inbounds [3 x double], [3 x double]* %939, i64 1
%941 = getelementptr inbounds [3 x double], [3 x double]* %940, i64 0, i64 1
store double %938, double* %941
%942 = load double, double* %25
%943 = load [3 x double]*, [3 x double]** %3
%944 = getelementptr inbounds [3 x double], [3 x double]* %943, i64 1
%945 = getelementptr inbounds [3 x double], [3 x double]* %944, i64 0, i64 2
store double %942, double* %945
br label %971
946: ; preds = %917
%947 = load double, double* %20
%948 = load [3 x double]*, [3 x double]** %3
%949 = getelementptr inbounds [3 x double], [3 x double]* %948, i64 0
%950 = getelementptr inbounds [3 x double], [3 x double]* %949, i64 0, i64 0
store double %947, double* %950
%951 = load double, double* %21
%952 = load [3 x double]*, [3 x double]** %3
%953 = getelementptr inbounds [3 x double], [3 x double]* %952, i64 0
%954 = getelementptr inbounds [3 x double], [3 x double]* %953, i64 0, i64 1
store double %951, double* %954
%955 = load double, double* %22
%956 = load [3 x double]*, [3 x double]** %3
%957 = getelementptr inbounds [3 x double], [3 x double]* %956, i64 0
%958 = getelementptr inbounds [3 x double], [3 x double]* %957, i64 0, i64 2
store double %955, double* %958
%959 = load double, double* %26
%960 = load [3 x double]*, [3 x double]** %3
%961 = getelementptr inbounds [3 x double], [3 x double]* %960, i64 1
%962 = getelementptr inbounds [3 x double], [3 x double]* %961, i64 0, i64 0
store double %959, double* %962
%963 = load double, double* %27
%964 = load [3 x double]*, [3 x double]** %3
%965 = getelementptr inbounds [3 x double], [3 x double]* %964, i64 1
%966 = getelementptr inbounds [3 x double], [3 x double]* %965, i64 0, i64 1
store double %963, double* %966
%967 = load double, double* %28
%968 = load [3 x double]*, [3 x double]** %3
%969 = getelementptr inbounds [3 x double], [3 x double]* %968, i64 1
%970 = getelementptr inbounds [3 x double], [3 x double]* %969, i64 0, i64 2
store double %967, double* %970
br label %971
971: ; preds = %946, %921
br label %972
972: ; preds = %971, %916
br label %973
973: ; preds = %972, %857
store i32 0, i32* %2
br label %974
974: ; preds = %973, %600, %491, %341, %232, %119
%975 = load i32, i32* %2
ret i32 %975
}

LLVM IR (-O2):
define i32 @check_rotation([3 x double]* nocapture %0) {
%2 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%3 = load double, double* %2
%4 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%5 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%6 = bitcast double* %4 to <2 x double>*
%7 = load <2 x double>, <2 x double>* %6
%8 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%9 = load double, double* %8
%10 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%11 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%12 = bitcast double* %10 to <2 x double>*
%13 = load <2 x double>, <2 x double>* %12
%14 = fneg double %3
%15 = extractelement <2 x double> %13, i64 1
%16 = fmul double %15, %14
%17 = extractelement <2 x double> %7, i64 1
%18 = tail call double @llvm.fmuladd.f64(double %17, double %9, double %16)
%19 = fneg <2 x double> %7
%20 = extractelement <2 x double> %13, i64 0
%21 = insertelement <2 x double> %13, double %9, i64 1
%22 = shufflevector <2 x double> %19, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%23 = fmul <2 x double> %21, %22
%24 = shufflevector <2 x double> %23, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%25 = insertelement <2 x double> poison, double %3, i64 0
%26 = extractelement <2 x double> %7, i64 0
%27 = shufflevector <2 x double> %25, <2 x double> %7, <2 x i32> <i32 0, i32 2>
%28 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> %13, <2 x double> %24)
%29 = fmul double %18, %18
%30 = extractelement <2 x double> %28, i64 1
%31 = tail call double @llvm.fmuladd.f64(double %30, double %30, double %29)
%32 = extractelement <2 x double> %28, i64 0
%33 = tail call double @llvm.fmuladd.f64(double %32, double %32, double %31)
%34 = tail call double @sqrt(double %33)
%35 = fcmp oeq double %34, 0.000000e+00
br i1 %35, label %321, label %36
36: ; preds = %1
%37 = fdiv double %18, %34
%38 = insertelement <2 x double> poison, double %34, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = fdiv <2 x double> %28, %39
%41 = fmul <2 x double> %7, %13
%42 = extractelement <2 x double> %41, i64 0
%43 = tail call double @llvm.fmuladd.f64(double %3, double %9, double %42)
%44 = tail call double @llvm.fmuladd.f64(double %17, double %15, double %43)
%45 = fcmp olt double %44, 0.000000e+00
%46 = fneg double %44
%47 = select i1 %45, double %46, double %44
%48 = fadd double %47, 1.000000e+00
%49 = tail call double @sqrt(double %48)
%50 = fsub double 1.000000e+00, %47
%51 = tail call double @sqrt(double %50)
%52 = fadd double %49, %51
%53 = fmul double %52, 5.000000e-01
%54 = extractelement <2 x double> %40, i64 1
%55 = extractelement <2 x double> %19, i64 0
%56 = fmul double %54, %55
%57 = tail call double @llvm.fmuladd.f64(double %37, double %3, double %56)
%58 = fcmp une double %57, 0.000000e+00
%59 = insertelement <2 x double> %7, double %3, i64 1
%60 = insertelement <2 x double> %40, double %37, i64 0
%61 = extractelement <2 x double> %40, i64 0
br i1 %58, label %85, label %62
62: ; preds = %36
%63 = insertelement <2 x double> poison, double %37, i64 0
%64 = fmul <2 x double> %40, %19
%65 = extractelement <2 x double> %64, i64 1
%66 = tail call double @llvm.fmuladd.f64(double %61, double %3, double %65)
%67 = fcmp une double %66, 0.000000e+00
%68 = select i1 %67, double %26, double %3
%69 = insertelement <2 x i1> poison, i1 %67, i64 0
%70 = shufflevector <2 x i1> %69, <2 x i1> poison, <2 x i32> zeroinitializer
%71 = insertelement <2 x double> poison, double %17, i64 0
%72 = insertelement <2 x double> %71, double %3, i64 1
%73 = select <2 x i1> %70, <2 x double> %72, <2 x double> %7
%74 = select i1 %67, double %37, double %54
%75 = shufflevector <2 x double> %63, <2 x double> %40, <2 x i32> <i32 0, i32 2>
%76 = select <2 x i1> %70, <2 x double> %40, <2 x double> %75
%77 = select i1 %67, i32 1, i32 2
%78 = extractelement <2 x double> %73, i64 0
%79 = fneg double %78
%80 = extractelement <2 x double> %76, i64 1
%81 = fmul double %80, %79
%82 = extractelement <2 x double> %73, i64 1
%83 = extractelement <2 x double> %76, i64 0
%84 = tail call double @llvm.fmuladd.f64(double %83, double %82, double %81)
br label %85
85: ; preds = %62, %36
%86 = phi double [ %84, %62 ], [ %57, %36 ]
%87 = phi double [ %68, %62 ], [ %17, %36 ]
%88 = phi double [ %74, %62 ], [ %61, %36 ]
%89 = phi i1 [ %67, %62 ], [ false, %36 ]
%90 = phi i32 [ %77, %62 ], [ 0, %36 ]
%91 = phi <2 x double> [ %73, %62 ], [ %59, %36 ]
%92 = phi <2 x double> [ %76, %62 ], [ %60, %36 ]
%93 = fcmp oeq double %86, 0.000000e+00
br i1 %93, label %321, label %94
94: ; preds = %85
%95 = fneg <2 x double> %92
%96 = insertelement <2 x double> poison, double %87, i64 0
%97 = shufflevector <2 x double> %96, <2 x double> poison, <2 x i32> zeroinitializer
%98 = fmul <2 x double> %97, %95
%99 = insertelement <2 x double> poison, double %88, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %100, <2 x double> %98)
%102 = extractelement <2 x double> %91, i64 1
%103 = fneg double %102
%104 = extractelement <2 x double> %92, i64 0
%105 = fmul double %104, %103
%106 = extractelement <2 x double> %91, i64 0
%107 = extractelement <2 x double> %92, i64 1
%108 = tail call double @llvm.fmuladd.f64(double %107, double %106, double %105)
%109 = insertelement <2 x double> poison, double %86, i64 0
%110 = insertelement <2 x double> %109, double %108, i64 1
%111 = fdiv <2 x double> %101, %110
%112 = insertelement <2 x double> poison, double %53, i64 0
%113 = shufflevector <2 x double> %112, <2 x double> poison, <2 x i32> zeroinitializer
%114 = fmul <2 x double> %113, %92
%115 = fdiv <2 x double> %114, %110
%116 = extractelement <2 x double> %111, i64 1
%117 = fmul double %116, %116
%118 = extractelement <2 x double> %111, i64 0
%119 = tail call double @llvm.fmuladd.f64(double %118, double %118, double %117)
%120 = fadd double %119, 1.000000e+00
%121 = extractelement <2 x double> %115, i64 1
%122 = fmul double %121, %116
%123 = extractelement <2 x double> %115, i64 0
%124 = tail call double @llvm.fmuladd.f64(double %118, double %123, double %122)
%125 = fmul double %121, %121
%126 = tail call double @llvm.fmuladd.f64(double %123, double %123, double %125)
%127 = fadd double %126, -1.000000e+00
%128 = fneg double %120
%129 = fmul double %127, %128
%130 = tail call double @llvm.fmuladd.f64(double %124, double %124, double %129)
%131 = fcmp olt double %130, 0.000000e+00
br i1 %131, label %321, label %132
132: ; preds = %94
%133 = fneg double %124
%134 = tail call double @sqrt(double %130)
%135 = tail call double @sqrt(double %130)
%136 = insertelement <2 x double> poison, double %134, i64 0
%137 = insertelement <2 x double> %136, double %133, i64 1
%138 = insertelement <2 x double> poison, double %124, i64 0
%139 = insertelement <2 x double> %138, double %135, i64 1
%140 = fsub <2 x double> %137, %139
%141 = insertelement <2 x double> poison, double %120, i64 0
%142 = shufflevector <2 x double> %141, <2 x double> poison, <2 x i32> zeroinitializer
%143 = fdiv <2 x double> %140, %142
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %144, <2 x double> %115)
%146 = shufflevector <2 x double> %143, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%147 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> <i32 1, i32 1>
%148 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %147, <2 x double> %115)
%149 = shufflevector <2 x double> %145, <2 x double> %143, <2 x i32> <i32 0, i32 2>
%150 = shufflevector <2 x double> %148, <2 x double> %143, <2 x i32> <i32 0, i32 3>
%151 = shufflevector <2 x double> %145, <2 x double> %148, <2 x i32> <i32 1, i32 3>
br i1 %89, label %158, label %152
152: ; preds = %132
%153 = icmp eq i32 %90, 2
br i1 %153, label %154, label %158
154: ; preds = %152
%155 = shufflevector <2 x double> %143, <2 x double> %145, <2 x i32> <i32 0, i32 3>
%156 = shufflevector <2 x double> %146, <2 x double> %148, <2 x i32> <i32 0, i32 3>
%157 = shufflevector <2 x double> %145, <2 x double> %148, <2 x i32> <i32 0, i32 2>
br label %158
158: ; preds = %132, %154, %152
%159 = phi double [ %104, %154 ], [ %104, %152 ], [ %88, %132 ]
%160 = phi double [ %107, %154 ], [ %88, %152 ], [ %104, %132 ]
%161 = phi double [ %88, %154 ], [ %107, %152 ], [ %107, %132 ]
%162 = phi <2 x double> [ %155, %154 ], [ %145, %152 ], [ %149, %132 ]
%163 = phi <2 x double> [ %156, %154 ], [ %148, %152 ], [ %150, %132 ]
%164 = phi <2 x double> [ %157, %154 ], [ %143, %152 ], [ %151, %132 ]
%165 = fneg double %20
%166 = fmul double %161, %165
%167 = tail call double @llvm.fmuladd.f64(double %159, double %9, double %166)
%168 = fcmp une double %167, 0.000000e+00
br i1 %168, label %184, label %169
169: ; preds = %158
%170 = fneg double %15
%171 = fmul double %161, %170
%172 = tail call double @llvm.fmuladd.f64(double %160, double %9, double %171)
%173 = fcmp une double %172, 0.000000e+00
%174 = select i1 %173, double %20, double %9
%175 = select i1 %173, double %15, double %20
%176 = select i1 %173, double %9, double %15
%177 = select i1 %173, double %159, double %161
%178 = select i1 %173, double %160, double %159
%179 = select i1 %173, double %161, double %160
%180 = select i1 %173, i32 1, i32 2
%181 = fneg double %175
%182 = fmul double %179, %181
%183 = tail call double @llvm.fmuladd.f64(double %178, double %176, double %182)
br label %184
184: ; preds = %169, %158
%185 = phi double [ %183, %169 ], [ %167, %158 ]
%186 = phi double [ %174, %169 ], [ %15, %158 ]
%187 = phi double [ %175, %169 ], [ %20, %158 ]
%188 = phi double [ %176, %169 ], [ %9, %158 ]
%189 = phi double [ %177, %169 ], [ %160, %158 ]
%190 = phi double [ %178, %169 ], [ %159, %158 ]
%191 = phi double [ %179, %169 ], [ %161, %158 ]
%192 = phi i1 [ %173, %169 ], [ false, %158 ]
%193 = phi i32 [ %180, %169 ], [ 0, %158 ]
%194 = fcmp oeq double %185, 0.000000e+00
br i1 %194, label %321, label %195
195: ; preds = %184
%196 = fneg double %190
%197 = fmul double %186, %196
%198 = tail call double @llvm.fmuladd.f64(double %187, double %189, double %197)
%199 = fdiv double %198, %185
%200 = fmul double %53, %190
%201 = fdiv double %200, %185
%202 = fneg double %191
%203 = fmul double %186, %202
%204 = tail call double @llvm.fmuladd.f64(double %188, double %189, double %203)
%205 = fneg double %188
%206 = fmul double %190, %205
%207 = tail call double @llvm.fmuladd.f64(double %191, double %187, double %206)
%208 = fmul double %53, %191
%209 = insertelement <2 x double> poison, double %208, i64 0
%210 = insertelement <2 x double> %209, double %204, i64 1
%211 = insertelement <2 x double> poison, double %207, i64 0
%212 = shufflevector <2 x double> %211, <2 x double> poison, <2 x i32> zeroinitializer
%213 = fdiv <2 x double> %210, %212
%214 = extractelement <2 x double> %213, i64 1
%215 = fmul double %214, %214
%216 = tail call double @llvm.fmuladd.f64(double %199, double %199, double %215)
%217 = fadd double %216, 1.000000e+00
%218 = extractelement <2 x double> %213, i64 0
%219 = fmul double %218, %214
%220 = tail call double @llvm.fmuladd.f64(double %199, double %201, double %219)
%221 = fmul <2 x double> %213, %213
%222 = extractelement <2 x double> %221, i64 0
%223 = tail call double @llvm.fmuladd.f64(double %201, double %201, double %222)
%224 = fadd double %223, -1.000000e+00
%225 = fneg double %217
%226 = fmul double %224, %225
%227 = tail call double @llvm.fmuladd.f64(double %220, double %220, double %226)
%228 = fcmp olt double %227, 0.000000e+00
br i1 %228, label %321, label %229
229: ; preds = %195
%230 = fneg double %220
%231 = tail call double @sqrt(double %227)
%232 = tail call double @sqrt(double %227)
%233 = insertelement <2 x double> poison, double %231, i64 0
%234 = insertelement <2 x double> %233, double %230, i64 1
%235 = insertelement <2 x double> poison, double %220, i64 0
%236 = insertelement <2 x double> %235, double %232, i64 1
%237 = fsub <2 x double> %234, %236
%238 = insertelement <2 x double> poison, double %217, i64 0
%239 = shufflevector <2 x double> %238, <2 x double> poison, <2 x i32> zeroinitializer
%240 = fdiv <2 x double> %237, %239
%241 = insertelement <2 x double> poison, double %199, i64 0
%242 = shufflevector <2 x double> %241, <2 x double> poison, <2 x i32> zeroinitializer
%243 = insertelement <2 x double> poison, double %201, i64 0
%244 = shufflevector <2 x double> %243, <2 x double> poison, <2 x i32> zeroinitializer
%245 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %242, <2 x double> %240, <2 x double> %244)
%246 = shufflevector <2 x double> %213, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%247 = shufflevector <2 x double> %213, <2 x double> undef, <2 x i32> zeroinitializer
%248 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %246, <2 x double> %240, <2 x double> %247)
%249 = icmp eq i32 %193, 2
%250 = select i1 %249, <2 x double> %240, <2 x double> %245
%251 = select i1 %249, <2 x double> %245, <2 x double> %240
%252 = select i1 %192, <2 x double> %245, <2 x double> %250
%253 = select i1 %192, <2 x double> %248, <2 x double> %251
%254 = select i1 %192, <2 x double> %240, <2 x double> %248
%255 = shufflevector <2 x double> %162, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%256 = fmul <2 x double> %255, %254
%257 = shufflevector <2 x double> %162, <2 x double> undef, <2 x i32> zeroinitializer
%258 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %257, <2 x double> %252, <2 x double> %256)
%259 = extractelement <2 x double> %164, i64 0
%260 = shufflevector <2 x double> %164, <2 x double> undef, <2 x i32> zeroinitializer
%261 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %260, <2 x double> %253, <2 x double> %258)
%262 = fcmp olt <2 x double> %261, zeroinitializer
%263 = fneg <2 x double> %261
%264 = select <2 x i1> %262, <2 x double> %263, <2 x double> %261
%265 = extractelement <2 x double> %163, i64 1
%266 = extractelement <2 x double> %254, i64 0
%267 = fmul double %265, %266
%268 = extractelement <2 x double> %163, i64 0
%269 = extractelement <2 x double> %252, i64 0
%270 = tail call double @llvm.fmuladd.f64(double %268, double %269, double %267)
%271 = extractelement <2 x double> %253, i64 0
%272 = extractelement <2 x double> %164, i64 1
%273 = tail call double @llvm.fmuladd.f64(double %272, double %271, double %270)
%274 = fcmp olt double %273, 0.000000e+00
%275 = fneg double %273
%276 = select i1 %274, double %275, double %273
%277 = extractelement <2 x double> %254, i64 1
%278 = fmul double %265, %277
%279 = extractelement <2 x double> %252, i64 1
%280 = tail call double @llvm.fmuladd.f64(double %268, double %279, double %278)
%281 = extractelement <2 x double> %253, i64 1
%282 = tail call double @llvm.fmuladd.f64(double %272, double %281, double %280)
%283 = fcmp olt double %282, 0.000000e+00
%284 = fneg double %282
%285 = select i1 %283, double %284, double %282
%286 = extractelement <2 x double> %264, i64 0
%287 = extractelement <2 x double> %264, i64 1
%288 = fcmp olt double %286, %287
br i1 %288, label %289, label %303
289: ; preds = %229
%290 = fcmp olt double %286, %276
br i1 %290, label %291, label %297
291: ; preds = %289
%292 = fcmp olt double %286, %285
br i1 %292, label %293, label %295
293: ; preds = %291
%294 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %162, <2 x double>* %294
store double %259, double* %5
br label %317
295: ; preds = %291
%296 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %163, <2 x double>* %296
store double %272, double* %5
br label %317
297: ; preds = %289
%298 = fcmp olt double %276, %285
%299 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %163, <2 x double>* %299
store double %272, double* %5
%300 = select i1 %298, double %269, double %279
%301 = select i1 %298, double %266, double %277
%302 = select i1 %298, double %271, double %281
br label %317
303: ; preds = %229
%304 = fcmp olt double %287, %276
br i1 %304, label %305, label %311
305: ; preds = %303
%306 = fcmp olt double %287, %285
br i1 %306, label %307, label %309
307: ; preds = %305
%308 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %162, <2 x double>* %308
store double %259, double* %5
br label %317
309: ; preds = %305
%310 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %163, <2 x double>* %310
store double %272, double* %5
br label %317
311: ; preds = %303
%312 = fcmp olt double %276, %285
%313 = bitcast [3 x double]* %0 to <2 x double>*
store <2 x double> %163, <2 x double>* %313
store double %272, double* %5
%314 = select i1 %312, double %269, double %279
%315 = select i1 %312, double %266, double %277
%316 = select i1 %312, double %271, double %281
br label %317
317: ; preds = %311, %297, %309, %307, %295, %293
%318 = phi double [ %269, %293 ], [ %279, %295 ], [ %279, %307 ], [ %279, %309 ], [ %300, %297 ], [ %314, %311 ]
%319 = phi double [ %266, %293 ], [ %277, %295 ], [ %277, %307 ], [ %277, %309 ], [ %301, %297 ], [ %315, %311 ]
%320 = phi double [ %271, %293 ], [ %281, %295 ], [ %281, %307 ], [ %281, %309 ], [ %302, %297 ], [ %316, %311 ]
store double %318, double* %8
store double %319, double* %10
store double %320, double* %11
br label %321
321: ; preds = %317, %195, %184, %94, %85, %1
%322 = phi i32 [ -1, %1 ], [ -1, %85 ], [ -1, %94 ], [ -1, %184 ], [ -1, %195 ], [ 0, %317 ]
ret i32 %322
}