void makeLookAtMatrix(double eyex, double eyey, double eyez, double centerx,
                      double centery, double centerz, double upx, double upy,
                      double upz, float m[16]) {
  double x[3], y[3], z[3], mag;
  z[0] = eyex - centerx;
  z[1] = eyey - centery;
  z[2] = eyez - centerz;
  mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
  if (mag) {
    z[0] /= mag;
    z[1] /= mag;
    z[2] /= mag;
  }
  y[0] = upx;
  y[1] = upy;
  y[2] = upz;
  x[0] = y[1] * z[2] - y[2] * z[1];
  x[1] = -y[0] * z[2] + y[2] * z[0];
  x[2] = y[0] * z[1] - y[1] * z[0];
  y[0] = z[1] * x[2] - z[2] * x[1];
  y[1] = -z[0] * x[2] + z[2] * x[0];
  y[2] = z[0] * x[1] - z[1] * x[0];
  mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
  if (mag) {
    x[0] /= mag;
    x[1] /= mag;
    x[2] /= mag;
  }
  mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
  if (mag) {
    y[0] /= mag;
    y[1] /= mag;
    y[2] /= mag;
  }
  m[0 * 4 + 0] = (float)x[0];
  m[0 * 4 + 1] = (float)x[1];
  m[0 * 4 + 2] = (float)x[2];
  m[0 * 4 + 3] = (float)(-x[0] * eyex + -x[1] * eyey + -x[2] * eyez);
  m[1 * 4 + 0] = (float)y[0];
  m[1 * 4 + 1] = (float)y[1];
  m[1 * 4 + 2] = (float)y[2];
  m[1 * 4 + 3] = (float)(-y[0] * eyex + -y[1] * eyey + -y[2] * eyez);
  m[2 * 4 + 0] = (float)z[0];
  m[2 * 4 + 1] = (float)z[1];
  m[2 * 4 + 2] = (float)z[2];
  m[2 * 4 + 3] = (float)(-z[0] * eyex + -z[1] * eyey + -z[2] * eyez);
  m[3 * 4 + 0] = 0.0;
  m[3 * 4 + 1] = 0.0;
  m[3 * 4 + 2] = 0.0;
  m[3 * 4 + 3] = 1.0;
}


x86 assembly (clang, -O0):
<makeLookAtMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
movsd  %xmm4,-0x28(%rbp)
movsd  %xmm5,-0x30(%rbp)
movsd  %xmm6,-0x38(%rbp)
movsd  %xmm7,-0x40(%rbp)
mov    %rdi,-0x48(%rbp)
movsd  -0x8(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f0 <makeLookAtMatrix+0xe0>
jp     11f0 <makeLookAtMatrix+0xe0>
jmp    1244 <makeLookAtMatrix+0x134>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x10(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1431 <makeLookAtMatrix+0x321>
jp     1431 <makeLookAtMatrix+0x321>
jmp    1473 <makeLookAtMatrix+0x363>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14ce <makeLookAtMatrix+0x3be>
jp     14ce <makeLookAtMatrix+0x3be>
jmp    1510 <makeLookAtMatrix+0x400>
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movsd  -0x50(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x8(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
movsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x10(%rax)
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x14(%rax)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x18(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x8(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x20(%rax)
movsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x24(%rax)
movsd  -0x90(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x28(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x8(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x48(%rbp),%rax
movss  0x88d(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<makeLookAtMatrix>:
push   %rbx
sub    $0xf0,%rsp
mov    %rdi,%rbx
movapd %xmm0,%xmm8
movapd %xmm0,%xmm9
subsd  %xmm3,%xmm9
movapd %xmm2,%xmm15
unpcklpd %xmm1,%xmm15
unpcklpd %xmm4,%xmm5
subpd  %xmm5,%xmm15
movapd %xmm15,%xmm0
mulpd  %xmm15,%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm9,%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm3,%xmm0
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
movapd %xmm2,0xc0(%rsp)
movsd  %xmm8,0x28(%rsp)
movapd %xmm1,0xb0(%rsp)
jb     1190 <makeLookAtMatrix+0x80>
sqrtsd %xmm0,%xmm0
jmp    11c9 <makeLookAtMatrix+0xb9>
movapd %xmm9,0x40(%rsp)
movapd %xmm15,0x30(%rsp)
movaps %xmm7,0x10(%rsp)
movaps %xmm6,(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm3,%xmm3
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm7
movapd 0x30(%rsp),%xmm15
movapd 0x40(%rsp),%xmm9
movsd  0x100(%rsp),%xmm1
ucomisd %xmm3,%xmm0
jne    11da <makeLookAtMatrix+0xca>
jnp    11e8 <makeLookAtMatrix+0xd8>
divsd  %xmm0,%xmm9
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm15
movapd %xmm15,%xmm2
unpckhpd %xmm15,%xmm2
movapd 0xe06(%rip),%xmm5
movapd %xmm2,%xmm8
xorpd  %xmm5,%xmm8
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
unpcklpd %xmm7,%xmm1
mulsd  %xmm15,%xmm7
subsd  %xmm0,%xmm7
movapd %xmm6,%xmm4
xorpd  %xmm5,%xmm4
movapd %xmm9,%xmm10
xorpd  %xmm5,%xmm10
movapd %xmm9,%xmm3
unpcklpd %xmm10,%xmm3
mulpd  %xmm3,%xmm1
unpcklpd %xmm6,%xmm4
mulpd  %xmm15,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm4,%xmm11
mulsd  %xmm15,%xmm11
movapd %xmm4,%xmm12
unpckhpd %xmm4,%xmm12
movapd %xmm2,%xmm14
mulsd  %xmm12,%xmm14
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
movapd %xmm8,%xmm6
unpcklpd %xmm15,%xmm6
mulpd  %xmm0,%xmm6
mulpd  %xmm4,%xmm3
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm12,%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm9,0x40(%rsp)
movapd %xmm15,0x30(%rsp)
movapd %xmm2,0xa0(%rsp)
movapd %xmm8,0x90(%rsp)
movapd %xmm10,0x80(%rsp)
jb     12db <makeLookAtMatrix+0x1cb>
sqrtsd %xmm0,%xmm0
jmp    1357 <makeLookAtMatrix+0x247>
movapd %xmm7,0x10(%rsp)
movapd %xmm3,0x70(%rsp)
movapd %xmm14,0x60(%rsp)
movapd %xmm12,0x50(%rsp)
movapd %xmm4,(%rsp)
movapd %xmm11,0xe0(%rsp)
movapd %xmm6,0xd0(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm1,%xmm1
movapd 0xd0(%rsp),%xmm6
movapd 0xe0(%rsp),%xmm11
movapd (%rsp),%xmm4
movapd 0x50(%rsp),%xmm12
movapd 0x60(%rsp),%xmm14
movapd 0x70(%rsp),%xmm3
movapd 0xcb6(%rip),%xmm5
movapd 0x10(%rsp),%xmm7
movapd 0x30(%rsp),%xmm15
subsd  %xmm11,%xmm14
addpd  %xmm6,%xmm3
ucomisd %xmm1,%xmm0
unpcklpd %xmm4,%xmm7
jne    136c <makeLookAtMatrix+0x25c>
jnp    1379 <makeLookAtMatrix+0x269>
divsd  %xmm0,%xmm12
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm7
movapd %xmm15,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm3,%xmm0
mulpd  %xmm3,%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm14,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm2,(%rsp)
jb     13bd <makeLookAtMatrix+0x2ad>
sqrtsd %xmm0,%xmm0
jmp    1409 <makeLookAtMatrix+0x2f9>
movapd %xmm7,0x10(%rsp)
movapd %xmm3,0x70(%rsp)
movapd %xmm14,0x60(%rsp)
movapd %xmm12,0x50(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm1,%xmm1
movapd 0x50(%rsp),%xmm12
movapd 0x60(%rsp),%xmm14
movapd 0x70(%rsp),%xmm3
movapd 0xc04(%rip),%xmm5
movapd 0x10(%rsp),%xmm7
movapd 0x30(%rsp),%xmm15
movapd 0x40(%rsp),%xmm8
movapd 0xc0(%rsp),%xmm10
movsd  0x28(%rsp),%xmm6
movapd 0xb0(%rsp),%xmm13
movapd 0xa0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm11
movapd 0x80(%rsp),%xmm4
ucomisd %xmm1,%xmm0
jne    144f <makeLookAtMatrix+0x33f>
jnp    145c <makeLookAtMatrix+0x34c>
divsd  %xmm0,%xmm14
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm3
movapd %xmm7,%xmm0
xorpd  %xmm5,%xmm0
cvtpd2ps %xmm7,%xmm1
unpckhpd %xmm7,%xmm7
mulsd  %xmm13,%xmm7
mulsd  %xmm6,%xmm0
subsd  %xmm7,%xmm0
movapd %xmm12,%xmm2
mulsd  %xmm10,%xmm2
subsd  %xmm2,%xmm0
unpcklpd %xmm0,%xmm12
cvtpd2ps %xmm12,%xmm0
unpcklpd %xmm0,%xmm1
movupd %xmm1,(%rbx)
xorpd  %xmm14,%xmm5
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mulsd  %xmm13,%xmm0
mulsd  %xmm6,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm3,%xmm0
mulsd  %xmm10,%xmm0
subsd  %xmm0,%xmm5
movapd %xmm3,%xmm0
unpcklpd %xmm5,%xmm0
cvtpd2ps %xmm0,%xmm0
movsd  %xmm14,%xmm3
cvtpd2ps %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x10(%rbx)
mulsd  %xmm13,%xmm11
mulsd  %xmm6,%xmm4
addsd  %xmm11,%xmm4
movapd (%rsp),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm4,%xmm0
unpcklpd %xmm0,%xmm15
unpcklpd %xmm9,%xmm8
cvtpd2ps %xmm15,%xmm0
cvtpd2ps %xmm8,%xmm1
unpcklpd %xmm0,%xmm1
movupd %xmm1,0x20(%rbx)
movaps 0xaf2(%rip),%xmm0
movups %xmm0,0x30(%rbx)
add    $0xf0,%rsp
pop    %rbx
ret

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

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