void fromToRotation(float from[3], float to[3], float mtx[3][3]) {
  float v[3];
  float e, h;
  {
    v[0] = from[1] * to[2] - from[2] * to[1];
    v[1] = from[2] * to[0] - from[0] * to[2];
    v[2] = from[0] * to[1] - from[1] * to[0];
  };
  e = (from[0] * to[0] + from[1] * to[1] + from[2] * to[2]);
  if (e > 1.0 - 0.000001) {
    mtx[0][0] = 1.0;
    mtx[0][1] = 0.0;
    mtx[0][2] = 0.0;
    mtx[1][0] = 0.0;
    mtx[1][1] = 1.0;
    mtx[1][2] = 0.0;
    mtx[2][0] = 0.0;
    mtx[2][1] = 0.0;
    mtx[2][2] = 1.0;
  } else if (e < -1.0 + 0.000001) {
    float up[3], left[3];
    float invlen;
    float fxx, fyy, fzz, fxy, fxz, fyz;
    float uxx, uyy, uzz, uxy, uxz, uyz;
    float lxx, lyy, lzz, lxy, lxz, lyz;
    left[0] = 0.0;
    left[1] = from[2];
    left[2] = -from[1];
    if ((left[0] * left[0] + left[1] * left[1] + left[2] * left[2]) <
        0.000001) {
      left[0] = -from[2];
      left[1] = 0.0;
      left[2] = from[0];
    }
    invlen =
        1.0 / sqrt((left[0] * left[0] + left[1] * left[1] + left[2] * left[2]));
    left[0] *= invlen;
    left[1] *= invlen;
    left[2] *= invlen;
    {
      up[0] = left[1] * from[2] - left[2] * from[1];
      up[1] = left[2] * from[0] - left[0] * from[2];
      up[2] = left[0] * from[1] - left[1] * from[0];
    };
    fxx = -from[0] * from[0];
    fyy = -from[1] * from[1];
    fzz = -from[2] * from[2];
    fxy = -from[0] * from[1];
    fxz = -from[0] * from[2];
    fyz = -from[1] * from[2];
    uxx = up[0] * up[0];
    uyy = up[1] * up[1];
    uzz = up[2] * up[2];
    uxy = up[0] * up[1];
    uxz = up[0] * up[2];
    uyz = up[1] * up[2];
    lxx = -left[0] * left[0];
    lyy = -left[1] * left[1];
    lzz = -left[2] * left[2];
    lxy = -left[0] * left[1];
    lxz = -left[0] * left[2];
    lyz = -left[1] * left[2];
    mtx[0][0] = fxx + uxx + lxx;
    mtx[0][1] = fxy + uxy + lxy;
    mtx[0][2] = fxz + uxz + lxz;
    mtx[1][0] = mtx[0][1];
    mtx[1][1] = fyy + uyy + lyy;
    mtx[1][2] = fyz + uyz + lyz;
    mtx[2][0] = mtx[0][2];
    mtx[2][1] = mtx[1][2];
    mtx[2][2] = fzz + uzz + lzz;
  } else {
    float hvx, hvz, hvxy, hvxz, hvyz;
    h = (1.0 - e) / (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    hvx = h * v[0];
    hvz = h * v[2];
    hvxy = hvx * v[1];
    hvxz = hvx * v[2];
    hvyz = hvz * v[1];
    mtx[0][0] = e + hvx * v[0];
    mtx[0][1] = hvxy - v[2];
    mtx[0][2] = hvxz + v[1];
    mtx[1][0] = hvxy + v[2];
    mtx[1][1] = e + h * v[1] * v[1];
    mtx[1][2] = hvyz - v[0];
    mtx[2][0] = hvxz - v[1];
    mtx[2][1] = hvyz + v[0];
    mtx[2][2] = e + hvz * v[2];
  }
}


x86 assembly (clang, -O0):
<fromToRotation>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdc9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12c0 <fromToRotation+0x1b0>
mov    -0x18(%rbp),%rax
movss  0xdd3(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  0xd9f(%rip),%xmm0
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x14(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x18(%rbp),%rax
movss  0xd6a(%rip),%xmm0
movss  %xmm0,0x20(%rax)
jmp    18fe <fromToRotation+0x7ee>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd37(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1754 <fromToRotation+0x644>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x44(%rbp),%xmm2
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcd2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1380 <fromToRotation+0x270>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x44(%rbp),%xmm2
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc4e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x44(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
addss  -0x70(%rbp),%xmm0
addss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x5c(%rbp),%xmm0
addss  -0x74(%rbp),%xmm0
addss  -0x8c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
addss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
jmp    18f9 <fromToRotation+0x7e9>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x8ab(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x24(%rbp),%xmm3
movss  -0x20(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x1c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x28(%rbp),%xmm1
movss  -0x94(%rbp),%xmm0
ff
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa0(%rbp),%xmm0
ff
addss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x9c(%rbp),%xmm0
ff
addss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x28(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xa4(%rbp),%xmm0
ff
subss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0xa0(%rbp),%xmm0
ff
subss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0xa4(%rbp),%xmm0
ff
addss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x28(%rbp),%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
jmp    18fe <fromToRotation+0x7ee>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fromToRotation>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rdx,%r14
movss  (%rdi),%xmm9
movss  0x4(%rdi),%xmm3
movss  0x8(%rsi),%xmm7
movss  0x8(%rdi),%xmm0
movss  (%rsi),%xmm5
movss  0x4(%rsi),%xmm6
movaps %xmm3,%xmm2
mulss  %xmm6,%xmm2
movaps %xmm9,%xmm4
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
movaps %xmm0,%xmm2
mulss  %xmm7,%xmm2
addss  %xmm4,%xmm2
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
ucomisd 0xeac(%rip),%xmm4
jbe    1184 <fromToRotation+0x74>
movss  0xec2(%rip),%xmm0
movups %xmm0,(%r14)
movups %xmm0,0x10(%r14)
movss  0xeb1(%rip),%xmm3
jmp    1477 <fromToRotation+0x367>
movsd  0xe8c(%rip),%xmm1
ucomisd %xmm4,%xmm1
jbe    1248 <fromToRotation+0x138>
mov    %rdi,%rbx
movaps 0xe60(%rip),%xmm4
movaps %xmm3,%xmm2
xorps  %xmm4,%xmm2
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm11,%xmm11
addss  %xmm11,%xmm1
mulss  %xmm3,%xmm3
addss  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movsd  0xe5b(%rip),%xmm3
xor    %eax,%eax
ucomisd %xmm1,%xmm3
seta   %cl
jbe    11df <fromToRotation+0xcf>
xorps  %xmm0,%xmm4
movaps %xmm4,%xmm11
mov    %cl,%al
movd   %eax,%xmm1
pshufd $0x50,%xmm1,%xmm6
pslld  $0x1f,%xmm6
psrad  $0x1f,%xmm6
movq   %xmm9,%xmm1
xorpd  %xmm3,%xmm3
shufps $0xe2,%xmm3,%xmm1
unpcklps %xmm2,%xmm0
andps  %xmm6,%xmm1
andnps %xmm0,%xmm6
orps   %xmm1,%xmm6
pshufd $0x55,%xmm6,%xmm0
movaps %xmm6,%xmm1
mulss  %xmm6,%xmm1
movaps %xmm11,%xmm2
mulss  %xmm11,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     134e <fromToRotation+0x23e>
sqrtsd %xmm0,%xmm0
jmp    1367 <fromToRotation+0x257>
movaps %xmm6,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm3,%xmm8
mulss  %xmm7,%xmm8
subss  %xmm1,%xmm8
mulss  %xmm9,%xmm7
mulss  %xmm5,%xmm0
subss  %xmm7,%xmm0
mulss  %xmm3,%xmm5
mulss  %xmm6,%xmm9
subss  %xmm5,%xmm9
movsd  0xda0(%rip),%xmm1
subsd  %xmm4,%xmm1
movaps %xmm0,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm8,%xmm4
mulss  %xmm8,%xmm4
addss  %xmm3,%xmm4
movaps %xmm9,%xmm3
mulss  %xmm9,%xmm3
addss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
divsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps %xmm8,%xmm4
mulss  %xmm1,%xmm4
movaps %xmm9,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm0,%xmm5
mulss  %xmm4,%xmm5
movaps %xmm9,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm8,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,(%r14)
movaps %xmm9,%xmm4
addss  %xmm5,%xmm4
subss  %xmm9,%xmm5
movss  %xmm5,0x4(%r14)
movaps %xmm0,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x8(%r14)
movss  %xmm4,0xc(%r14)
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x10(%r14)
movaps %xmm7,%xmm1
subss  %xmm8,%xmm1
movss  %xmm1,0x14(%r14)
subss  %xmm0,%xmm6
movss  %xmm6,0x18(%r14)
addss  %xmm8,%xmm7
movss  %xmm7,0x1c(%r14)
mulss  %xmm9,%xmm3
addss  %xmm2,%xmm3
jmp    1477 <fromToRotation+0x367>
movaps %xmm11,0x10(%rsp)
movaps %xmm6,(%rsp)
call   1030 <sqrt@plt>
movaps (%rsp),%xmm6
movaps 0x10(%rsp),%xmm11
movsd  0xcb1(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mulss  %xmm0,%xmm11
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm6
movsd  0x4(%rbx),%xmm3
movss  (%rbx),%xmm1
movaps %xmm6,%xmm8
shufps $0x55,%xmm6,%xmm8
movaps %xmm11,%xmm4
shufps $0xd4,%xmm6,%xmm4
shufps $0x52,%xmm6,%xmm4
mulps  %xmm3,%xmm4
movaps %xmm1,%xmm5
shufps $0xd4,%xmm3,%xmm5
shufps $0x52,%xmm3,%xmm5
movaps %xmm1,%xmm9
movaps %xmm11,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm1,%xmm10
movaps %xmm3,%xmm0
movlhps %xmm1,%xmm0
movlhps %xmm3,%xmm1
shufps $0x49,%xmm3,%xmm0
movaps %xmm3,%xmm12
shufps $0x55,%xmm3,%xmm12
mulps  %xmm6,%xmm5
subps  %xmm4,%xmm5
mulss  %xmm6,%xmm9
subss  %xmm9,%xmm2
movaps %xmm5,%xmm4
movaps %xmm2,%xmm3
movaps %xmm2,%xmm7
shufps $0xd4,%xmm5,%xmm7
unpcklps %xmm5,%xmm2
shufps $0x54,%xmm5,%xmm5
mulss  %xmm4,%xmm4
mulss  %xmm3,%xmm3
shufps $0x24,%xmm7,%xmm2
mulps  %xmm5,%xmm2
mulss  %xmm10,%xmm10
subss  %xmm10,%xmm4
movaps %xmm11,%xmm5
mulss  %xmm11,%xmm5
subss  %xmm5,%xmm4
movss  %xmm4,(%r14)
shufps $0xa8,%xmm1,%xmm1
mulps  %xmm0,%xmm1
subps  %xmm1,%xmm2
shufps $0x0,%xmm6,%xmm11
shufps $0x41,%xmm6,%xmm6
mulps  %xmm11,%xmm6
subps  %xmm6,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movss  %xmm0,0x4(%r14)
movups %xmm2,0x8(%r14)
movss  %xmm2,0x18(%r14)
shufps $0xff,%xmm2,%xmm2
movss  %xmm2,0x1c(%r14)
mulss  %xmm12,%xmm12
subss  %xmm12,%xmm3
mulss  %xmm8,%xmm8
subss  %xmm8,%xmm3
movss  %xmm3,0x20(%r14)
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @fromToRotation(float* nocapture %0, float* nocapture %1, [3 x float]* %2) {
%4 = getelementptr inbounds float, float* %0, i64 1
%5 = load float, float* %4
%6 = getelementptr inbounds float, float* %1, i64 2
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %0, i64 2
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %1, i64 1
%11 = load float, float* %10
%12 = fneg float %9
%13 = fmul float %11, %12
%14 = tail call float @llvm.fmuladd.f32(float %5, float %7, float %13)
%15 = load float, float* %1
%16 = load float, float* %0
%17 = fneg float %16
%18 = fmul float %7, %17
%19 = tail call float @llvm.fmuladd.f32(float %9, float %15, float %18)
%20 = fneg float %5
%21 = fmul float %15, %20
%22 = tail call float @llvm.fmuladd.f32(float %16, float %11, float %21)
%23 = fmul float %5, %11
%24 = tail call float @llvm.fmuladd.f32(float %16, float %15, float %23)
%25 = tail call float @llvm.fmuladd.f32(float %9, float %7, float %24)
%26 = fpext float %25 to double
%27 = fcmp ogt double %26, 0x3FEFFFFDE7210BE9
br i1 %27, label %28, label %32
28: ; preds = %3
%29 = bitcast [3 x float]* %2 to <4 x float>*
store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00>, <4 x float>* %29
%30 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 1, i64 1
%31 = bitcast float* %30 to <4 x float>*
store <4 x float> <float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00>, <4 x float>* %31
br label %154
32: ; preds = %3
%33 = fcmp olt double %26, 0xBFEFFFFDE7210BE9
br i1 %33, label %34, label %123
34: ; preds = %32
%35 = fmul float %9, %9
%36 = fadd float %35, 0.000000e+00
%37 = tail call float @llvm.fmuladd.f32(float %5, float %5, float %36)
%38 = fpext float %37 to double
%39 = fcmp olt double %38, 0x3EB0C6F7A0B5ED8D
%40 = select i1 %39, float %12, float 0.000000e+00
%41 = insertelement <2 x i1> poison, i1 %39, i64 0
%42 = shufflevector <2 x i1> %41, <2 x i1> poison, <2 x i32> zeroinitializer
%43 = insertelement <2 x float> <float 0.000000e+00, float poison>, float %16, i64 1
%44 = insertelement <2 x float> poison, float %9, i64 0
%45 = insertelement <2 x float> %44, float %20, i64 1
%46 = select <2 x i1> %42, <2 x float> %43, <2 x float> %45
%47 = fmul <2 x float> %46, %46
%48 = extractelement <2 x float> %47, i64 0
%49 = tail call float @llvm.fmuladd.f32(float %40, float %40, float %48)
%50 = extractelement <2 x float> %46, i64 1
%51 = tail call float @llvm.fmuladd.f32(float %50, float %50, float %49)
%52 = fpext float %51 to double
%53 = tail call double @sqrt(double %52)
%54 = fdiv double 1.000000e+00, %53
%55 = fptrunc double %54 to float
%56 = fmul float %40, %55
%57 = insertelement <2 x float> poison, float %55, i64 0
%58 = shufflevector <2 x float> %57, <2 x float> poison, <2 x i32> zeroinitializer
%59 = fmul <2 x float> %46, %58
%60 = shufflevector <2 x float> %59, <2 x float> poison, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%61 = bitcast float* %4 to <2 x float>*
%62 = load <2 x float>, <2 x float>* %61
%63 = shufflevector <2 x float> %62, <2 x float> poison, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%64 = load float, float* %0
%65 = extractelement <2 x float> %59, i64 1
%66 = insertelement <2 x float> poison, float %65, i64 0
%67 = insertelement <2 x float> %66, float %56, i64 1
%68 = fneg <2 x float> %67
%69 = fmul <2 x float> %62, %68
%70 = extractelement <2 x float> %62, i64 1
%71 = insertelement <2 x float> poison, float %70, i64 0
%72 = insertelement <2 x float> %71, float %64, i64 1
%73 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %59, <2 x float> %72, <2 x float> %69)
%74 = shufflevector <2 x float> %73, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
%75 = extractelement <2 x float> %59, i64 0
%76 = fneg float %75
%77 = fmul float %64, %76
%78 = extractelement <2 x float> %62, i64 0
%79 = tail call float @llvm.fmuladd.f32(float %56, float %78, float %77)
%80 = extractelement <2 x float> %73, i64 0
%81 = fmul <2 x float> %73, %73
%82 = extractelement <2 x float> %81, i64 0
%83 = fmul float %79, %79
%84 = insertelement <4 x float> poison, float %79, i64 0
%85 = insertelement <4 x float> %84, float %80, i64 1
%86 = extractelement <2 x float> %73, i64 1
%87 = insertelement <4 x float> %85, float %86, i64 2
%88 = insertelement <4 x float> %87, float %79, i64 3
%89 = fmul <4 x float> %74, %88
%90 = fmul float %64, %64
%91 = fsub float %82, %90
%92 = fmul float %56, %56
%93 = fsub float %91, %92
%94 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 0
store float %93, float* %94
%95 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 1
%96 = shufflevector <2 x float> %62, <2 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
%97 = shufflevector <2 x float> %62, <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%98 = insertelement <4 x float> %97, float %64, i64 2
%99 = shufflevector <4 x float> %98, <4 x float> %63, <4 x i32> <i32 0, i32 1, i32 2, i32 5>
%100 = insertelement <4 x float> %96, float %64, i64 1
%101 = shufflevector <4 x float> %100, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 0>
%102 = fmul <4 x float> %99, %101
%103 = shufflevector <4 x float> %102, <4 x float> poison, <4 x i32> <i32 1, i32 2, i32 0, i32 3>
%104 = fsub <4 x float> %89, %103
%105 = insertelement <4 x float> poison, float %56, i64 0
%106 = shufflevector <4 x float> %105, <4 x float> %60, <4 x i32> <i32 0, i32 4, i32 undef, i32 undef>
%107 = shufflevector <4 x float> %106, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%108 = shufflevector <2 x float> %59, <2 x float> poison, <4 x i32> <i32 1, i32 0, i32 undef, i32 undef>
%109 = shufflevector <4 x float> %108, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 0>
%110 = fmul <4 x float> %107, %109
%111 = fsub <4 x float> %104, %110
%112 = extractelement <4 x float> %111, i64 1
store float %112, float* %95
%113 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 2
%114 = bitcast float* %113 to <4 x float>*
store <4 x float> %111, <4 x float>* %114
%115 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 2, i64 0
%116 = extractelement <4 x float> %111, i64 0
store float %116, float* %115
%117 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 2, i64 1
%118 = extractelement <4 x float> %111, i64 3
store float %118, float* %117
%119 = fmul float %70, %70
%120 = fsub float %83, %119
%121 = fmul float %65, %65
%122 = fsub float %120, %121
br label %154
123: ; preds = %32
%124 = fsub double 1.000000e+00, %26
%125 = fmul float %19, %19
%126 = tail call float @llvm.fmuladd.f32(float %14, float %14, float %125)
%127 = tail call float @llvm.fmuladd.f32(float %22, float %22, float %126)
%128 = fpext float %127 to double
%129 = fdiv double %124, %128
%130 = fptrunc double %129 to float
%131 = fmul float %14, %130
%132 = fmul float %22, %130
%133 = fmul float %19, %131
%134 = fmul float %22, %131
%135 = fmul float %19, %132
%136 = tail call float @llvm.fmuladd.f32(float %131, float %14, float %25)
%137 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 0
store float %136, float* %137
%138 = fsub float %133, %22
%139 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 1
store float %138, float* %139
%140 = fadd float %19, %134
%141 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 0, i64 2
store float %140, float* %141
%142 = fadd float %22, %133
%143 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 1, i64 0
store float %142, float* %143
%144 = fmul float %19, %130
%145 = tail call float @llvm.fmuladd.f32(float %144, float %19, float %25)
%146 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 1, i64 1
store float %145, float* %146
%147 = fsub float %135, %14
%148 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 1, i64 2
store float %147, float* %148
%149 = fsub float %134, %19
%150 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 2, i64 0
store float %149, float* %150
%151 = fadd float %14, %135
%152 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 2, i64 1
store float %151, float* %152
%153 = tail call float @llvm.fmuladd.f32(float %132, float %22, float %25)
br label %154
154: ; preds = %34, %123, %28
%155 = phi float [ %122, %34 ], [ %153, %123 ], [ 1.000000e+00, %28 ]
%156 = getelementptr inbounds [3 x float], [3 x float]* %2, i64 2, i64 2
store float %155, float* %156
ret void
}