#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double sqrt(double);
void create_matrix_normalized_c(double *matrix, double *origo, double *point_a,
                                double *point_b) {
  double r;
  point_a[0] -= origo[0];
  point_a[1] -= origo[1];
  point_a[2] -= origo[2];
  r = sqrt(point_a[0] * point_a[0] + point_a[1] * point_a[1] +
           point_a[2] * point_a[2]);
  matrix[8] = point_a[0] / r;
  matrix[9] = point_a[1] / r;
  matrix[10] = point_a[2] / r;
  matrix[12] = origo[0];
  matrix[13] = origo[1];
  matrix[14] = origo[2];
  point_b[0] -= origo[0];
  point_b[1] -= origo[1];
  point_b[2] -= origo[2];
  matrix[0] = matrix[9] * point_b[2] - matrix[10] * point_b[1];
  matrix[1] = matrix[10] * point_b[0] - matrix[8] * point_b[2];
  matrix[2] = matrix[8] * point_b[1] - matrix[9] * point_b[0];
  r = sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1] +
           matrix[2] * matrix[2]);
  matrix[0] = matrix[0] / r;
  matrix[1] = matrix[1] / r;
  matrix[2] = matrix[2] / r;
  matrix[4] = matrix[9] * matrix[2] - matrix[10] * matrix[1];
  matrix[5] = matrix[10] * matrix[0] - matrix[8] * matrix[2];
  matrix[6] = matrix[8] * matrix[1] - matrix[9] * matrix[0];
  r = sqrt(matrix[4] * matrix[4] + matrix[5] * matrix[5] +
           matrix[6] * matrix[6]);
  matrix[4] = matrix[4] / r;
  matrix[5] = matrix[5] / r;
  matrix[6] = matrix[6] / r;
  matrix[3] = 0;
  matrix[7] = 0;
  matrix[11] = 0;
  matrix[15] = 1;
}


x86 assembly (clang, -O0):
<create_matrix_normalized_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x70(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x58(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa5c(%rip),%xmm0
movsd  %xmm0,0x78(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_matrix_normalized_c>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,%r12
movsd  (%rdx),%xmm1
movsd  0x8(%rdx),%xmm2
subsd  (%rsi),%xmm1
movsd  %xmm1,(%rdx)
subsd  0x8(%rsi),%xmm2
movsd  %xmm2,0x8(%rdx)
movsd  0x10(%rdx),%xmm0
subsd  0x10(%rsi),%xmm0
movsd  %xmm0,0x10(%rdx)
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm0
jb     1172 <create_matrix_normalized_c+0x62>
sqrtsd %xmm0,%xmm0
jmp    117b <create_matrix_normalized_c+0x6b>
call   1030 <sqrt@plt>
xorpd  %xmm5,%xmm5
movsd  (%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%r12)
movsd  0x8(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x48(%r12)
movsd  0x10(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%r12)
movsd  (%r15),%xmm0
movsd  %xmm0,0x60(%r12)
movsd  0x8(%r15),%xmm0
movsd  %xmm0,0x68(%r12)
movsd  0x10(%r15),%xmm0
movsd  %xmm0,0x70(%r12)
movsd  (%r14),%xmm0
subsd  (%r15),%xmm0
movsd  0x8(%r14),%xmm2
movsd  %xmm0,(%r14)
subsd  0x8(%r15),%xmm2
movsd  %xmm2,0x8(%r14)
movsd  0x10(%r14),%xmm1
subsd  0x10(%r15),%xmm1
movsd  %xmm1,0x10(%r14)
movsd  0x40(%r12),%xmm0
movsd  0x48(%r12),%xmm3
movsd  0x50(%r12),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,(%r12)
movsd  0x10(%r14),%xmm2
mulsd  %xmm0,%xmm2
mulsd  (%r14),%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,0x8(%r12)
mulsd  (%r14),%xmm3
mulsd  0x8(%r14),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%r12)
mulsd  %xmm4,%xmm4
mulsd  %xmm1,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm5,%xmm0
jb     127a <create_matrix_normalized_c+0x16a>
sqrtsd %xmm0,%xmm0
jmp    127f <create_matrix_normalized_c+0x16f>
call   1030 <sqrt@plt>
movupd (%r12),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
divpd  %xmm1,%xmm2
movupd %xmm2,(%r12)
movsd  0x10(%r12),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r12)
movupd 0x48(%r12),%xmm3
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movsd  0x40(%r12),%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm1,%xmm5
unpcklpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
mulsd  %xmm3,%xmm2
shufpd $0x1,%xmm4,%xmm3
mulpd  %xmm5,%xmm3
subpd  %xmm3,%xmm1
movupd %xmm1,0x20(%r12)
mulsd  %xmm4,%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,0x30(%r12)
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm2
unpckhpd %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1323 <create_matrix_normalized_c+0x213>
sqrtsd %xmm0,%xmm0
jmp    1328 <create_matrix_normalized_c+0x218>
call   1030 <sqrt@plt>
movupd 0x20(%r12),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x20(%r12)
movsd  0x30(%r12),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%r12)
movq   $0x0,0x18(%r12)
movq   $0x0,0x38(%r12)
movq   $0x0,0x58(%r12)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x78(%r12)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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