void fromToRotation(float from[3], float to[3], float mtx[3][3]) {
  float v[3];
  float e, h, f;
  {
    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]);
  f = (e < 0) ? -e : e;
  if (f > 1.0 - 0.000001) {
    float u[3], v[3];
    float x[3];
    float c1, c2, c3;
    int i, j;
    x[0] = (from[0] > 0.0) ? from[0] : -from[0];
    x[1] = (from[1] > 0.0) ? from[1] : -from[1];
    x[2] = (from[2] > 0.0) ? from[2] : -from[2];
    if (x[0] < x[1]) {
      if (x[0] < x[2]) {
        x[0] = 1.0;
        x[1] = x[2] = 0.0;
      } else {
        x[2] = 1.0;
        x[0] = x[1] = 0.0;
      }
    } else {
      if (x[1] < x[2]) {
        x[1] = 1.0;
        x[0] = x[2] = 0.0;
      } else {
        x[2] = 1.0;
        x[0] = x[1] = 0.0;
      }
    }
    u[0] = x[0] - from[0];
    u[1] = x[1] - from[1];
    u[2] = x[2] - from[2];
    v[0] = x[0] - to[0];
    v[1] = x[1] - to[1];
    v[2] = x[2] - to[2];
    c1 = 2.0 / (u[0] * u[0] + u[1] * u[1] + u[2] * u[2]);
    c2 = 2.0 / (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    c3 = c1 * c2 * (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        mtx[i][j] = -c1 * u[i] * u[j] - c2 * v[i] * v[j] + c3 * v[i] * u[j];
      }
      mtx[i][i] += 1.0;
    }
  } else {
    float hvx, hvz, hvxy, hvxz, hvyz;
    h = 1.0 / (1.0 + e);
    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    $0x10,%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)
xorps  %xmm0,%xmm0
ucomiss -0x28(%rbp),%xmm0
jbe    123c <fromToRotation+0x13c>
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    1246 <fromToRotation+0x146>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd9f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    167a <fromToRotation+0x57a>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1299 <fromToRotation+0x199>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    12b6 <fromToRotation+0x1b6>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12f3 <fromToRotation+0x1f3>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
jmp    1311 <fromToRotation+0x211>
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    134e <fromToRotation+0x24e>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    136c <fromToRotation+0x26c>
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x4c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13e3 <fromToRotation+0x2e3>
movss  -0x54(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    13c1 <fromToRotation+0x2c1>
movss  0xc71(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    13de <fromToRotation+0x2de>
movss  0xc4f(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    143a <fromToRotation+0x33a>
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1418 <fromToRotation+0x318>
movss  0xc1a(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1435 <fromToRotation+0x335>
movss  0xbf8(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    143a <fromToRotation+0x33a>
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x38(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb2c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xae5(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm3
movss  -0x38(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x34(%rbp),%xmm1
movss  -0x40(%rbp),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x3,-0x64(%rbp)
jge    1675 <fromToRotation+0x575>
movl   $0x0,-0x68(%rbp)
cmpl   $0x3,-0x68(%rbp)
jge    1636 <fromToRotation+0x536>
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movslq -0x64(%rbp),%rax
mulss  -0x3c(%rbp,%rax,4),%xmm1
movslq -0x68(%rbp),%rax
movss  -0x3c(%rbp,%rax,4),%xmm2
movss  -0x5c(%rbp),%xmm0
movslq -0x64(%rbp),%rax
mulss  -0x48(%rbp,%rax,4),%xmm0
movslq -0x68(%rbp),%rax
mulss  -0x48(%rbp,%rax,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movslq -0x64(%rbp),%rax
mulss  -0x48(%rbp,%rax,4),%xmm0
movslq -0x68(%rbp),%rax
movss  -0x3c(%rbp,%rax,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1591 <fromToRotation+0x491>
mov    -0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9ae(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1580 <fromToRotation+0x480>
jmp    17c5 <fromToRotation+0x6c5>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x97d(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x971(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x6c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x70(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x74(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x78(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x74(%rbp),%xmm0
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  -0x7c(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x78(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x7c(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x28(%rbp),%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fromToRotation>:
movss  (%rdi),%xmm14
movss  0x4(%rdi),%xmm8
movss  0x8(%rsi),%xmm15
movss  0x8(%rdi),%xmm11
movss  (%rsi),%xmm12
movss  0x4(%rsi),%xmm2
movaps 0xed8(%rip),%xmm0
movaps %xmm8,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm14,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm1,%xmm3
movaps %xmm11,%xmm1
mulss  %xmm15,%xmm1
addss  %xmm3,%xmm1
movaps %xmm1,%xmm3
xorps  %xmm0,%xmm3
xorps  %xmm10,%xmm10
movaps %xmm1,%xmm5
cmpltss %xmm10,%xmm5
andps  %xmm5,%xmm3
andnps %xmm1,%xmm5
orps   %xmm3,%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm5,%xmm3
ucomisd 0xe9b(%rip),%xmm3
jbe    145a <fromToRotation+0x35a>
movaps %xmm11,%xmm5
xorps  %xmm0,%xmm5
movaps %xmm14,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm8,%xmm6
xorps  %xmm0,%xmm6
xorps  %xmm3,%xmm3
cmpltss %xmm14,%xmm3
movaps %xmm3,%xmm0
andnps %xmm1,%xmm3
xorps  %xmm1,%xmm1
cmpltss %xmm8,%xmm1
movaps %xmm1,%xmm7
andps  %xmm8,%xmm7
andnps %xmm6,%xmm1
orps   %xmm7,%xmm1
xorps  %xmm6,%xmm6
cmpltss %xmm11,%xmm6
movaps %xmm6,%xmm7
andnps %xmm5,%xmm6
andps  %xmm14,%xmm0
andps  %xmm11,%xmm7
orps   %xmm7,%xmm6
xor    %eax,%eax
ucomiss %xmm1,%xmm6
orps   %xmm0,%xmm3
seta   %dil
movss  0xe3d(%rip),%xmm4
movaps %xmm4,%xmm0
ja     11eb <fromToRotation+0xeb>
xorps  %xmm0,%xmm0
xor    %esi,%esi
ucomiss %xmm3,%xmm6
seta   %cl
movaps %xmm4,%xmm9
ja     11fd <fromToRotation+0xfd>
xorps  %xmm9,%xmm9
ucomiss %xmm3,%xmm1
mov    %cl,%sil
mov    %dil,%al
cmova  %esi,%eax
xorps  %xmm13,%xmm13
ja     1217 <fromToRotation+0x117>
xorps  %xmm9,%xmm9
movaps %xmm0,%xmm13
test   %al,%al
jne    121f <fromToRotation+0x11f>
movaps %xmm4,%xmm10
movaps %xmm9,%xmm1
subss  %xmm14,%xmm1
movaps %xmm13,%xmm6
subss  %xmm8,%xmm6
movaps %xmm10,%xmm14
subss  %xmm11,%xmm14
subss  %xmm12,%xmm9
subss  %xmm2,%xmm13
subss  %xmm15,%xmm10
movaps %xmm6,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movaps %xmm14,%xmm0
mulss  %xmm14,%xmm0
addss  %xmm2,%xmm0
movss  0xdb3(%rip),%xmm8
movaps %xmm8,%xmm11
divss  %xmm0,%xmm11
movaps %xmm13,%xmm0
mulss  %xmm13,%xmm0
movaps %xmm9,%xmm2
mulss  %xmm9,%xmm2
addss  %xmm0,%xmm2
movaps %xmm10,%xmm0
mulss  %xmm10,%xmm0
addss  %xmm2,%xmm0
divss  %xmm0,%xmm8
movaps %xmm11,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm6,%xmm2
mulss  %xmm13,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm9,%xmm3
addss  %xmm2,%xmm3
movaps %xmm14,%xmm12
mulss  %xmm10,%xmm12
addss  %xmm3,%xmm12
mulss  %xmm0,%xmm12
movaps 0xd27(%rip),%xmm0
xorps  %xmm0,%xmm11
xorps  %xmm0,%xmm8
movaps %xmm1,%xmm2
mulss  %xmm11,%xmm2
movaps %xmm9,%xmm5
mulss  %xmm8,%xmm5
movaps %xmm12,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm5,%xmm7
mulss  %xmm9,%xmm7
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  %xmm7,%xmm3
movaps %xmm0,%xmm7
mulss  %xmm1,%xmm7
addss  %xmm3,%xmm7
movaps %xmm5,%xmm3
mulss  %xmm13,%xmm3
movaps %xmm4,%xmm15
movaps %xmm2,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm3,%xmm4
movaps %xmm0,%xmm3
mulss  %xmm6,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,0x4(%rdx)
mulss  %xmm10,%xmm5
mulss  %xmm14,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm14,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0x8(%rdx)
addss  %xmm15,%xmm7
movss  %xmm7,(%rdx)
movaps %xmm6,%xmm3
mulss  %xmm11,%xmm3
movaps %xmm13,%xmm2
mulss  %xmm8,%xmm2
movaps %xmm12,%xmm0
mulss  %xmm13,%xmm0
movaps %xmm2,%xmm4
mulss  %xmm9,%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movaps %xmm0,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,0xc(%rdx)
movaps %xmm2,%xmm4
mulss  %xmm13,%xmm4
movaps %xmm3,%xmm5
mulss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movaps %xmm0,%xmm4
mulss  %xmm6,%xmm4
addss  %xmm5,%xmm4
mulss  %xmm10,%xmm2
mulss  %xmm14,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm14,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,0x14(%rdx)
addss  %xmm15,%xmm4
movss  %xmm4,0x10(%rdx)
mulss  %xmm14,%xmm11
mulss  %xmm10,%xmm8
mulss  %xmm10,%xmm12
mulss  %xmm8,%xmm9
movaps %xmm11,%xmm0
mulss  %xmm1,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x18(%rdx)
mulss  %xmm8,%xmm13
movaps %xmm11,%xmm0
mulss  %xmm6,%xmm0
addss  %xmm13,%xmm0
mulss  %xmm12,%xmm6
addss  %xmm0,%xmm6
movss  %xmm6,0x1c(%rdx)
mulss  %xmm10,%xmm8
mulss  %xmm14,%xmm11
addss  %xmm8,%xmm11
mulss  %xmm14,%xmm12
addss  %xmm11,%xmm12
addss  %xmm15,%xmm12
movss  %xmm12,0x20(%rdx)
ret
movaps %xmm2,%xmm0
mulss  %xmm11,%xmm0
movaps %xmm8,%xmm3
mulss  %xmm15,%xmm3
subss  %xmm0,%xmm3
mulss  %xmm14,%xmm15
mulss  %xmm12,%xmm11
subss  %xmm15,%xmm11
mulss  %xmm8,%xmm12
mulss  %xmm2,%xmm14
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  0xb81(%rip),%xmm5
addsd  %xmm5,%xmm0
divsd  %xmm0,%xmm5
cvtsd2ss %xmm5,%xmm5
subss  %xmm12,%xmm14
movaps %xmm3,%xmm6
mulss  %xmm5,%xmm6
movaps %xmm14,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm11,%xmm7
mulss  %xmm6,%xmm7
movaps %xmm14,%xmm2
mulss  %xmm6,%xmm2
movaps %xmm11,%xmm4
mulss  %xmm0,%xmm4
mulss  %xmm3,%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,(%rdx)
movaps %xmm14,%xmm6
addss  %xmm7,%xmm6
subss  %xmm14,%xmm7
movss  %xmm7,0x4(%rdx)
movaps %xmm11,%xmm7
addss  %xmm2,%xmm7
movss  %xmm7,0x8(%rdx)
movss  %xmm6,0xc(%rdx)
mulss  %xmm11,%xmm5
mulss  %xmm11,%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,0x10(%rdx)
movaps %xmm4,%xmm5
subss  %xmm3,%xmm5
movss  %xmm5,0x14(%rdx)
subss  %xmm11,%xmm2
movss  %xmm2,0x18(%rdx)
addss  %xmm3,%xmm4
movss  %xmm4,0x1c(%rdx)
mulss  %xmm14,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rdx)
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 float
%11 = alloca [3 x float]
%12 = alloca [3 x float]
%13 = alloca [3 x float]
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca i32
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
store float* %0, float** %4
store float* %1, float** %5
store [3 x float]* %2, [3 x float]** %6
%24 = load float*, float** %4
%25 = getelementptr inbounds float, float* %24, i64 1
%26 = load float, float* %25
%27 = load float*, float** %5
%28 = getelementptr inbounds float, float* %27, i64 2
%29 = load float, float* %28
%30 = load float*, float** %4
%31 = getelementptr inbounds float, float* %30, i64 2
%32 = load float, float* %31
%33 = load float*, float** %5
%34 = getelementptr inbounds float, float* %33, i64 1
%35 = load float, float* %34
%36 = fmul float %32, %35
%37 = fneg float %36
%38 = call float @llvm.fmuladd.f32(float %26, float %29, float %37)
%39 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
store float %38, float* %39
%40 = load float*, float** %4
%41 = getelementptr inbounds float, float* %40, i64 2
%42 = load float, float* %41
%43 = load float*, float** %5
%44 = getelementptr inbounds float, float* %43, i64 0
%45 = load float, float* %44
%46 = load float*, float** %4
%47 = getelementptr inbounds float, float* %46, i64 0
%48 = load float, float* %47
%49 = load float*, float** %5
%50 = getelementptr inbounds float, float* %49, i64 2
%51 = load float, float* %50
%52 = fmul float %48, %51
%53 = fneg float %52
%54 = call float @llvm.fmuladd.f32(float %42, float %45, float %53)
%55 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
store float %54, float* %55
%56 = load float*, float** %4
%57 = getelementptr inbounds float, float* %56, i64 0
%58 = load float, float* %57
%59 = load float*, float** %5
%60 = getelementptr inbounds float, float* %59, i64 1
%61 = load float, float* %60
%62 = load float*, float** %4
%63 = getelementptr inbounds float, float* %62, i64 1
%64 = load float, float* %63
%65 = load float*, float** %5
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
%68 = fmul float %64, %67
%69 = fneg float %68
%70 = call float @llvm.fmuladd.f32(float %58, float %61, float %69)
%71 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
store float %70, float* %71
%72 = load float*, float** %4
%73 = getelementptr inbounds float, float* %72, i64 0
%74 = load float, float* %73
%75 = load float*, float** %5
%76 = getelementptr inbounds float, float* %75, i64 0
%77 = load float, float* %76
%78 = load float*, float** %4
%79 = getelementptr inbounds float, float* %78, i64 1
%80 = load float, float* %79
%81 = load float*, float** %5
%82 = getelementptr inbounds float, float* %81, i64 1
%83 = load float, float* %82
%84 = fmul float %80, %83
%85 = call float @llvm.fmuladd.f32(float %74, float %77, float %84)
%86 = load float*, float** %4
%87 = getelementptr inbounds float, float* %86, i64 2
%88 = load float, float* %87
%89 = load float*, float** %5
%90 = getelementptr inbounds float, float* %89, i64 2
%91 = load float, float* %90
%92 = call float @llvm.fmuladd.f32(float %88, float %91, float %85)
store float %92, float* %8
%93 = load float, float* %8
%94 = fcmp olt float %93, 0.000000e+00
br i1 %94, label %95, label %98
95: ; preds = %3
%96 = load float, float* %8
%97 = fneg float %96
br label %100
98: ; preds = %3
%99 = load float, float* %8
br label %100
100: ; preds = %98, %95
%101 = phi float [ %97, %95 ], [ %99, %98 ]
store float %101, float* %10
%102 = load float, float* %10
%103 = fpext float %102 to double
%104 = fcmp ogt double %103, 0x3FEFFFFDE7210BE9
br i1 %104, label %105, label %359
105: ; preds = %100
%106 = load float*, float** %4
%107 = getelementptr inbounds float, float* %106, i64 0
%108 = load float, float* %107
%109 = fpext float %108 to double
%110 = fcmp ogt double %109, 0.000000e+00
br i1 %110, label %111, label %115
111: ; preds = %105
%112 = load float*, float** %4
%113 = getelementptr inbounds float, float* %112, i64 0
%114 = load float, float* %113
br label %120
115: ; preds = %105
%116 = load float*, float** %4
%117 = getelementptr inbounds float, float* %116, i64 0
%118 = load float, float* %117
%119 = fneg float %118
br label %120
120: ; preds = %115, %111
%121 = phi float [ %114, %111 ], [ %119, %115 ]
%122 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float %121, float* %122
%123 = load float*, float** %4
%124 = getelementptr inbounds float, float* %123, i64 1
%125 = load float, float* %124
%126 = fpext float %125 to double
%127 = fcmp ogt double %126, 0.000000e+00
br i1 %127, label %128, label %132
128: ; preds = %120
%129 = load float*, float** %4
%130 = getelementptr inbounds float, float* %129, i64 1
%131 = load float, float* %130
br label %137
132: ; preds = %120
%133 = load float*, float** %4
%134 = getelementptr inbounds float, float* %133, i64 1
%135 = load float, float* %134
%136 = fneg float %135
br label %137
137: ; preds = %132, %128
%138 = phi float [ %131, %128 ], [ %136, %132 ]
%139 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float %138, float* %139
%140 = load float*, float** %4
%141 = getelementptr inbounds float, float* %140, i64 2
%142 = load float, float* %141
%143 = fpext float %142 to double
%144 = fcmp ogt double %143, 0.000000e+00
br i1 %144, label %145, label %149
145: ; preds = %137
%146 = load float*, float** %4
%147 = getelementptr inbounds float, float* %146, i64 2
%148 = load float, float* %147
br label %154
149: ; preds = %137
%150 = load float*, float** %4
%151 = getelementptr inbounds float, float* %150, i64 2
%152 = load float, float* %151
%153 = fneg float %152
br label %154
154: ; preds = %149, %145
%155 = phi float [ %148, %145 ], [ %153, %149 ]
%156 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float %155, float* %156
%157 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
%158 = load float, float* %157
%159 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
%160 = load float, float* %159
%161 = fcmp olt float %158, %160
br i1 %161, label %162, label %177
162: ; preds = %154
%163 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
%164 = load float, float* %163
%165 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%166 = load float, float* %165
%167 = fcmp olt float %164, %166
br i1 %167, label %168, label %172
168: ; preds = %162
%169 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float 1.000000e+00, float* %169
%170 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float 0.000000e+00, float* %170
%171 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float 0.000000e+00, float* %171
br label %176
172: ; preds = %162
%173 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float 1.000000e+00, float* %173
%174 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float 0.000000e+00, float* %174
%175 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float 0.000000e+00, float* %175
br label %176
176: ; preds = %172, %168
br label %192
177: ; preds = %154
%178 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
%179 = load float, float* %178
%180 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%181 = load float, float* %180
%182 = fcmp olt float %179, %181
br i1 %182, label %183, label %187
183: ; preds = %177
%184 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float 1.000000e+00, float* %184
%185 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float 0.000000e+00, float* %185
%186 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float 0.000000e+00, float* %186
br label %191
187: ; preds = %177
%188 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
store float 1.000000e+00, float* %188
%189 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
store float 0.000000e+00, float* %189
%190 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
store float 0.000000e+00, float* %190
br label %191
191: ; preds = %187, %183
br label %192
192: ; preds = %191, %176
%193 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
%194 = load float, float* %193
%195 = load float*, float** %4
%196 = getelementptr inbounds float, float* %195, i64 0
%197 = load float, float* %196
%198 = fsub float %194, %197
%199 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 0
store float %198, float* %199
%200 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
%201 = load float, float* %200
%202 = load float*, float** %4
%203 = getelementptr inbounds float, float* %202, i64 1
%204 = load float, float* %203
%205 = fsub float %201, %204
%206 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 1
store float %205, float* %206
%207 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%208 = load float, float* %207
%209 = load float*, float** %4
%210 = getelementptr inbounds float, float* %209, i64 2
%211 = load float, float* %210
%212 = fsub float %208, %211
%213 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 2
store float %212, float* %213
%214 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
%215 = load float, float* %214
%216 = load float*, float** %5
%217 = getelementptr inbounds float, float* %216, i64 0
%218 = load float, float* %217
%219 = fsub float %215, %218
%220 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 0
store float %219, float* %220
%221 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
%222 = load float, float* %221
%223 = load float*, float** %5
%224 = getelementptr inbounds float, float* %223, i64 1
%225 = load float, float* %224
%226 = fsub float %222, %225
%227 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 1
store float %226, float* %227
%228 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%229 = load float, float* %228
%230 = load float*, float** %5
%231 = getelementptr inbounds float, float* %230, i64 2
%232 = load float, float* %231
%233 = fsub float %229, %232
%234 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 2
store float %233, float* %234
%235 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 0
%236 = load float, float* %235
%237 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 0
%238 = load float, float* %237
%239 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 1
%240 = load float, float* %239
%241 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 1
%242 = load float, float* %241
%243 = fmul float %240, %242
%244 = call float @llvm.fmuladd.f32(float %236, float %238, float %243)
%245 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 2
%246 = load float, float* %245
%247 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 2
%248 = load float, float* %247
%249 = call float @llvm.fmuladd.f32(float %246, float %248, float %244)
%250 = fpext float %249 to double
%251 = fdiv double 2.000000e+00, %250
%252 = fptrunc double %251 to float
store float %252, float* %14
%253 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 0
%254 = load float, float* %253
%255 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 0
%256 = load float, float* %255
%257 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 1
%258 = load float, float* %257
%259 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 1
%260 = load float, float* %259
%261 = fmul float %258, %260
%262 = call float @llvm.fmuladd.f32(float %254, float %256, float %261)
%263 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 2
%264 = load float, float* %263
%265 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 2
%266 = load float, float* %265
%267 = call float @llvm.fmuladd.f32(float %264, float %266, float %262)
%268 = fpext float %267 to double
%269 = fdiv double 2.000000e+00, %268
%270 = fptrunc double %269 to float
store float %270, float* %15
%271 = load float, float* %14
%272 = load float, float* %15
%273 = fmul float %271, %272
%274 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 0
%275 = load float, float* %274
%276 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 0
%277 = load float, float* %276
%278 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 1
%279 = load float, float* %278
%280 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 1
%281 = load float, float* %280
%282 = fmul float %279, %281
%283 = call float @llvm.fmuladd.f32(float %275, float %277, float %282)
%284 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 2
%285 = load float, float* %284
%286 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 2
%287 = load float, float* %286
%288 = call float @llvm.fmuladd.f32(float %285, float %287, float %283)
%289 = fmul float %273, %288
store float %289, float* %16
store i32 0, i32* %17
br label %290
290: ; preds = %355, %192
%291 = load i32, i32* %17
%292 = icmp slt i32 %291, 3
br i1 %292, label %293, label %358
293: ; preds = %290
store i32 0, i32* %18
br label %294
294: ; preds = %340, %293
%295 = load i32, i32* %18
%296 = icmp slt i32 %295, 3
br i1 %296, label %297, label %343
297: ; preds = %294
%298 = load float, float* %14
%299 = fneg float %298
%300 = load i32, i32* %17
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 %301
%303 = load float, float* %302
%304 = fmul float %299, %303
%305 = load i32, i32* %18
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 %306
%308 = load float, float* %307
%309 = load float, float* %15
%310 = load i32, i32* %17
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 %311
%313 = load float, float* %312
%314 = fmul float %309, %313
%315 = load i32, i32* %18
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 %316
%318 = load float, float* %317
%319 = fmul float %314, %318
%320 = fneg float %319
%321 = call float @llvm.fmuladd.f32(float %304, float %308, float %320)
%322 = load float, float* %16
%323 = load i32, i32* %17
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds [3 x float], [3 x float]* %12, i64 0, i64 %324
%326 = load float, float* %325
%327 = fmul float %322, %326
%328 = load i32, i32* %18
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [3 x float], [3 x float]* %11, i64 0, i64 %329
%331 = load float, float* %330
%332 = call float @llvm.fmuladd.f32(float %327, float %331, float %321)
%333 = load [3 x float]*, [3 x float]** %6
%334 = load i32, i32* %17
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [3 x float], [3 x float]* %333, i64 %335
%337 = load i32, i32* %18
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [3 x float], [3 x float]* %336, i64 0, i64 %338
store float %332, float* %339
br label %340
340: ; preds = %297
%341 = load i32, i32* %18
%342 = add nsw i32 %341, 1
store i32 %342, i32* %18
br label %294
343: ; preds = %294
%344 = load [3 x float]*, [3 x float]** %6
%345 = load i32, i32* %17
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [3 x float], [3 x float]* %344, i64 %346
%348 = load i32, i32* %17
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [3 x float], [3 x float]* %347, i64 0, i64 %349
%351 = load float, float* %350
%352 = fpext float %351 to double
%353 = fadd double %352, 1.000000e+00
%354 = fptrunc double %353 to float
store float %354, float* %350
br label %355
355: ; preds = %343
%356 = load i32, i32* %17
%357 = add nsw i32 %356, 1
store i32 %357, i32* %17
br label %290
358: ; preds = %290
br label %454
359: ; preds = %100
%360 = load float, float* %8
%361 = fpext float %360 to double
%362 = fadd double 1.000000e+00, %361
%363 = fdiv double 1.000000e+00, %362
%364 = fptrunc double %363 to float
store float %364, float* %9
%365 = load float, float* %9
%366 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%367 = load float, float* %366
%368 = fmul float %365, %367
store float %368, float* %19
%369 = load float, float* %9
%370 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%371 = load float, float* %370
%372 = fmul float %369, %371
store float %372, float* %20
%373 = load float, float* %19
%374 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%375 = load float, float* %374
%376 = fmul float %373, %375
store float %376, float* %21
%377 = load float, float* %19
%378 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%379 = load float, float* %378
%380 = fmul float %377, %379
store float %380, float* %22
%381 = load float, float* %20
%382 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%383 = load float, float* %382
%384 = fmul float %381, %383
store float %384, float* %23
%385 = load float, float* %8
%386 = load float, float* %19
%387 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%388 = load float, float* %387
%389 = call float @llvm.fmuladd.f32(float %386, float %388, float %385)
%390 = load [3 x float]*, [3 x float]** %6
%391 = getelementptr inbounds [3 x float], [3 x float]* %390, i64 0
%392 = getelementptr inbounds [3 x float], [3 x float]* %391, i64 0, i64 0
store float %389, float* %392
%393 = load float, float* %21
%394 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%395 = load float, float* %394
%396 = fsub float %393, %395
%397 = load [3 x float]*, [3 x float]** %6
%398 = getelementptr inbounds [3 x float], [3 x float]* %397, i64 0
%399 = getelementptr inbounds [3 x float], [3 x float]* %398, i64 0, i64 1
store float %396, float* %399
%400 = load float, float* %22
%401 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%402 = load float, float* %401
%403 = fadd float %400, %402
%404 = load [3 x float]*, [3 x float]** %6
%405 = getelementptr inbounds [3 x float], [3 x float]* %404, i64 0
%406 = getelementptr inbounds [3 x float], [3 x float]* %405, i64 0, i64 2
store float %403, float* %406
%407 = load float, float* %21
%408 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%409 = load float, float* %408
%410 = fadd float %407, %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 0
store float %410, float* %413
%414 = load float, float* %8
%415 = load float, float* %9
%416 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%417 = load float, float* %416
%418 = fmul float %415, %417
%419 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%420 = load float, float* %419
%421 = call float @llvm.fmuladd.f32(float %418, float %420, float %414)
%422 = load [3 x float]*, [3 x float]** %6
%423 = getelementptr inbounds [3 x float], [3 x float]* %422, i64 1
%424 = getelementptr inbounds [3 x float], [3 x float]* %423, i64 0, i64 1
store float %421, float* %424
%425 = load float, float* %23
%426 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%427 = load float, float* %426
%428 = fsub float %425, %427
%429 = load [3 x float]*, [3 x float]** %6
%430 = getelementptr inbounds [3 x float], [3 x float]* %429, i64 1
%431 = getelementptr inbounds [3 x float], [3 x float]* %430, i64 0, i64 2
store float %428, float* %431
%432 = load float, float* %22
%433 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%434 = load float, float* %433
%435 = fsub float %432, %434
%436 = load [3 x float]*, [3 x float]** %6
%437 = getelementptr inbounds [3 x float], [3 x float]* %436, i64 2
%438 = getelementptr inbounds [3 x float], [3 x float]* %437, i64 0, i64 0
store float %435, float* %438
%439 = load float, float* %23
%440 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%441 = load float, float* %440
%442 = fadd float %439, %441
%443 = load [3 x float]*, [3 x float]** %6
%444 = getelementptr inbounds [3 x float], [3 x float]* %443, i64 2
%445 = getelementptr inbounds [3 x float], [3 x float]* %444, i64 0, i64 1
store float %442, float* %445
%446 = load float, float* %8
%447 = load float, float* %20
%448 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%449 = load float, float* %448
%450 = call float @llvm.fmuladd.f32(float %447, float %449, float %446)
%451 = load [3 x float]*, [3 x float]** %6
%452 = getelementptr inbounds [3 x float], [3 x float]* %451, i64 2
%453 = getelementptr inbounds [3 x float], [3 x float]* %452, i64 0, i64 2
store float %450, float* %453
br label %454
454: ; preds = %359, %358
ret void
}

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