#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_b(double *matrix, double *origo, double *point_x,
                                double *point_y) {
  double r;
  point_x[0] -= origo[0];
  point_x[1] -= origo[1];
  point_x[2] -= origo[2];
  r = sqrt(point_x[0] * point_x[0] + point_x[1] * point_x[1] +
           point_x[2] * point_x[2]);
  matrix[0] = point_x[0] / r;
  matrix[1] = point_x[1] / r;
  matrix[2] = point_x[2] / r;
  matrix[12] = 0;
  matrix[13] = 0;
  matrix[14] = 0;
  point_y[0] -= origo[0];
  point_y[1] -= origo[1];
  point_y[2] -= origo[2];
  r = matrix[0] * point_y[0] + matrix[1] * point_y[1] + matrix[2] * point_y[2];
  matrix[4] = point_y[0] - matrix[0] * r;
  matrix[5] = point_y[1] - matrix[1] * r;
  matrix[6] = point_y[2] - matrix[2] * r;
  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[8] = matrix[1] * matrix[6] - matrix[2] * matrix[5];
  matrix[9] = matrix[2] * matrix[4] - matrix[0] * matrix[6];
  matrix[10] = matrix[0] * matrix[5] - matrix[1] * matrix[4];
  r = sqrt(matrix[8] * matrix[8] + matrix[9] * matrix[9] +
           matrix[10] * matrix[10]);
  matrix[8] = matrix[8] / r;
  matrix[9] = matrix[9] / r;
  matrix[10] = matrix[10] / r;
  matrix[3] = origo[0];
  matrix[7] = origo[1];
  matrix[11] = origo[2];
  matrix[15] = 1;
}


x86 assembly (clang, -O0):
<create_matrix_normalized_b>:
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,(%rax)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x60(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x68(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
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  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
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
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x28(%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,0x40(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x30(%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,0x48(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x20(%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,0x50(%rax)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x48(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x8(%rbp),%rax
movsd  0x48(%rax),%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x8(%rbp),%rax
movsd  0x50(%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,0x18(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x8(%rbp),%rax
movsd  0xa36(%rip),%xmm0
movsd  %xmm0,0x78(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_matrix_normalized_b>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rsi,%r14
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  %xmm7,%xmm7
ucomisd %xmm7,%xmm0
jb     1172 <create_matrix_normalized_b+0x62>
sqrtsd %xmm0,%xmm0
jmp    117b <create_matrix_normalized_b+0x6b>
call   1030 <sqrt@plt>
xorpd  %xmm7,%xmm7
movsd  (%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12)
movsd  0x8(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12)
movsd  0x10(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r12)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x60(%r12)
movq   $0x0,0x70(%r12)
movsd  (%r15),%xmm1
subsd  (%r14),%xmm1
movsd  0x8(%r15),%xmm0
movsd  %xmm1,(%r15)
subsd  0x8(%r14),%xmm0
movsd  %xmm0,0x8(%r15)
movsd  0x10(%r15),%xmm2
subsd  0x10(%r14),%xmm2
movsd  %xmm2,0x10(%r15)
movsd  (%r12),%xmm3
movsd  0x8(%r12),%xmm4
mulsd  %xmm4,%xmm0
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm0,%xmm5
movsd  0x10(%r12),%xmm6
mulsd  %xmm6,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,0x20(%r12)
movsd  0x8(%r15),%xmm3
mulsd  %xmm2,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x28(%r12)
movsd  0x10(%r15),%xmm0
mulsd  %xmm6,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x30(%r12)
mulsd  %xmm3,%xmm3
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm7,%xmm0
jb     1275 <create_matrix_normalized_b+0x165>
sqrtsd %xmm0,%xmm0
jmp    127a <create_matrix_normalized_b+0x16a>
call   1030 <sqrt@plt>
movupd 0x20(%r12),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
divpd  %xmm1,%xmm2
movupd %xmm2,0x20(%r12)
movsd  0x30(%r12),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%r12)
movupd 0x8(%r12),%xmm3
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movsd  (%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,0x40(%r12)
mulsd  %xmm4,%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,0x50(%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     131f <create_matrix_normalized_b+0x20f>
sqrtsd %xmm0,%xmm0
jmp    1324 <create_matrix_normalized_b+0x214>
call   1030 <sqrt@plt>
movupd 0x40(%r12),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x40(%r12)
movsd  0x50(%r12),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%r12)
movsd  (%r14),%xmm0
movsd  %xmm0,0x18(%r12)
movsd  0x8(%r14),%xmm0
movsd  %xmm0,0x38(%r12)
movsd  0x10(%r14),%xmm0
movsd  %xmm0,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_b(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 0
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 1
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 2
store double %71, double* %73
%74 = load double*, double** %5
%75 = getelementptr inbounds double, double* %74, i64 12
store double 0.000000e+00, double* %75
%76 = load double*, double** %5
%77 = getelementptr inbounds double, double* %76, i64 13
store double 0.000000e+00, double* %77
%78 = load double*, double** %5
%79 = getelementptr inbounds double, double* %78, i64 14
store double 0.000000e+00, double* %79
%80 = load double*, double** %6
%81 = getelementptr inbounds double, double* %80, i64 0
%82 = load double, double* %81
%83 = load double*, double** %8
%84 = getelementptr inbounds double, double* %83, i64 0
%85 = load double, double* %84
%86 = fsub double %85, %82
store double %86, double* %84
%87 = load double*, double** %6
%88 = getelementptr inbounds double, double* %87, i64 1
%89 = load double, double* %88
%90 = load double*, double** %8
%91 = getelementptr inbounds double, double* %90, i64 1
%92 = load double, double* %91
%93 = fsub double %92, %89
store double %93, double* %91
%94 = load double*, double** %6
%95 = getelementptr inbounds double, double* %94, i64 2
%96 = load double, double* %95
%97 = load double*, double** %8
%98 = getelementptr inbounds double, double* %97, i64 2
%99 = load double, double* %98
%100 = fsub double %99, %96
store double %100, double* %98
%101 = load double*, double** %5
%102 = getelementptr inbounds double, double* %101, i64 0
%103 = load double, double* %102
%104 = load double*, double** %8
%105 = getelementptr inbounds double, double* %104, i64 0
%106 = load double, double* %105
%107 = load double*, double** %5
%108 = getelementptr inbounds double, double* %107, i64 1
%109 = load double, double* %108
%110 = load double*, double** %8
%111 = getelementptr inbounds double, double* %110, i64 1
%112 = load double, double* %111
%113 = fmul double %109, %112
%114 = call double @llvm.fmuladd.f64(double %103, double %106, double %113)
%115 = load double*, double** %5
%116 = getelementptr inbounds double, double* %115, i64 2
%117 = load double, double* %116
%118 = load double*, double** %8
%119 = getelementptr inbounds double, double* %118, i64 2
%120 = load double, double* %119
%121 = call double @llvm.fmuladd.f64(double %117, double %120, double %114)
store double %121, double* %9
%122 = load double*, double** %8
%123 = getelementptr inbounds double, double* %122, i64 0
%124 = load double, double* %123
%125 = load double*, double** %5
%126 = getelementptr inbounds double, double* %125, i64 0
%127 = load double, double* %126
%128 = load double, double* %9
%129 = fneg double %127
%130 = call double @llvm.fmuladd.f64(double %129, double %128, double %124)
%131 = load double*, double** %5
%132 = getelementptr inbounds double, double* %131, i64 4
store double %130, double* %132
%133 = load double*, double** %8
%134 = getelementptr inbounds double, double* %133, i64 1
%135 = load double, double* %134
%136 = load double*, double** %5
%137 = getelementptr inbounds double, double* %136, i64 1
%138 = load double, double* %137
%139 = load double, double* %9
%140 = fneg double %138
%141 = call double @llvm.fmuladd.f64(double %140, double %139, double %135)
%142 = load double*, double** %5
%143 = getelementptr inbounds double, double* %142, i64 5
store double %141, double* %143
%144 = load double*, double** %8
%145 = getelementptr inbounds double, double* %144, i64 2
%146 = load double, double* %145
%147 = load double*, double** %5
%148 = getelementptr inbounds double, double* %147, i64 2
%149 = load double, double* %148
%150 = load double, double* %9
%151 = fneg double %149
%152 = call double @llvm.fmuladd.f64(double %151, double %150, double %146)
%153 = load double*, double** %5
%154 = getelementptr inbounds double, double* %153, i64 6
store double %152, double* %154
%155 = load double*, double** %5
%156 = getelementptr inbounds double, double* %155, i64 4
%157 = load double, double* %156
%158 = load double*, double** %5
%159 = getelementptr inbounds double, double* %158, i64 4
%160 = load double, double* %159
%161 = load double*, double** %5
%162 = getelementptr inbounds double, double* %161, i64 5
%163 = load double, double* %162
%164 = load double*, double** %5
%165 = getelementptr inbounds double, double* %164, i64 5
%166 = load double, double* %165
%167 = fmul double %163, %166
%168 = call double @llvm.fmuladd.f64(double %157, double %160, double %167)
%169 = load double*, double** %5
%170 = getelementptr inbounds double, double* %169, i64 6
%171 = load double, double* %170
%172 = load double*, double** %5
%173 = getelementptr inbounds double, double* %172, i64 6
%174 = load double, double* %173
%175 = call double @llvm.fmuladd.f64(double %171, double %174, double %168)
%176 = call double @sqrt(double %175)
store double %176, double* %9
%177 = load double*, double** %5
%178 = getelementptr inbounds double, double* %177, i64 4
%179 = load double, double* %178
%180 = load double, double* %9
%181 = fdiv double %179, %180
%182 = load double*, double** %5
%183 = getelementptr inbounds double, double* %182, i64 4
store double %181, double* %183
%184 = load double*, double** %5
%185 = getelementptr inbounds double, double* %184, i64 5
%186 = load double, double* %185
%187 = load double, double* %9
%188 = fdiv double %186, %187
%189 = load double*, double** %5
%190 = getelementptr inbounds double, double* %189, i64 5
store double %188, double* %190
%191 = load double*, double** %5
%192 = getelementptr inbounds double, double* %191, i64 6
%193 = load double, double* %192
%194 = load double, double* %9
%195 = fdiv double %193, %194
%196 = load double*, double** %5
%197 = getelementptr inbounds double, double* %196, i64 6
store double %195, double* %197
%198 = load double*, double** %5
%199 = getelementptr inbounds double, double* %198, i64 1
%200 = load double, double* %199
%201 = load double*, double** %5
%202 = getelementptr inbounds double, double* %201, i64 6
%203 = load double, double* %202
%204 = load double*, double** %5
%205 = getelementptr inbounds double, double* %204, i64 2
%206 = load double, double* %205
%207 = load double*, double** %5
%208 = getelementptr inbounds double, double* %207, i64 5
%209 = load double, double* %208
%210 = fmul double %206, %209
%211 = fneg double %210
%212 = call double @llvm.fmuladd.f64(double %200, double %203, double %211)
%213 = load double*, double** %5
%214 = getelementptr inbounds double, double* %213, i64 8
store double %212, double* %214
%215 = load double*, double** %5
%216 = getelementptr inbounds double, double* %215, i64 2
%217 = load double, double* %216
%218 = load double*, double** %5
%219 = getelementptr inbounds double, double* %218, i64 4
%220 = load double, double* %219
%221 = load double*, double** %5
%222 = getelementptr inbounds double, double* %221, i64 0
%223 = load double, double* %222
%224 = load double*, double** %5
%225 = getelementptr inbounds double, double* %224, i64 6
%226 = load double, double* %225
%227 = fmul double %223, %226
%228 = fneg double %227
%229 = call double @llvm.fmuladd.f64(double %217, double %220, double %228)
%230 = load double*, double** %5
%231 = getelementptr inbounds double, double* %230, i64 9
store double %229, double* %231
%232 = load double*, double** %5
%233 = getelementptr inbounds double, double* %232, i64 0
%234 = load double, double* %233
%235 = load double*, double** %5
%236 = getelementptr inbounds double, double* %235, i64 5
%237 = load double, double* %236
%238 = load double*, double** %5
%239 = getelementptr inbounds double, double* %238, i64 1
%240 = load double, double* %239
%241 = load double*, double** %5
%242 = getelementptr inbounds double, double* %241, i64 4
%243 = load double, double* %242
%244 = fmul double %240, %243
%245 = fneg double %244
%246 = call double @llvm.fmuladd.f64(double %234, double %237, double %245)
%247 = load double*, double** %5
%248 = getelementptr inbounds double, double* %247, i64 10
store double %246, double* %248
%249 = load double*, double** %5
%250 = getelementptr inbounds double, double* %249, i64 8
%251 = load double, double* %250
%252 = load double*, double** %5
%253 = getelementptr inbounds double, double* %252, i64 8
%254 = load double, double* %253
%255 = load double*, double** %5
%256 = getelementptr inbounds double, double* %255, i64 9
%257 = load double, double* %256
%258 = load double*, double** %5
%259 = getelementptr inbounds double, double* %258, i64 9
%260 = load double, double* %259
%261 = fmul double %257, %260
%262 = call double @llvm.fmuladd.f64(double %251, double %254, double %261)
%263 = load double*, double** %5
%264 = getelementptr inbounds double, double* %263, i64 10
%265 = load double, double* %264
%266 = load double*, double** %5
%267 = getelementptr inbounds double, double* %266, i64 10
%268 = load double, double* %267
%269 = call double @llvm.fmuladd.f64(double %265, double %268, double %262)
%270 = call double @sqrt(double %269)
store double %270, double* %9
%271 = load double*, double** %5
%272 = getelementptr inbounds double, double* %271, i64 8
%273 = load double, double* %272
%274 = load double, double* %9
%275 = fdiv double %273, %274
%276 = load double*, double** %5
%277 = getelementptr inbounds double, double* %276, i64 8
store double %275, double* %277
%278 = load double*, double** %5
%279 = getelementptr inbounds double, double* %278, i64 9
%280 = load double, double* %279
%281 = load double, double* %9
%282 = fdiv double %280, %281
%283 = load double*, double** %5
%284 = getelementptr inbounds double, double* %283, i64 9
store double %282, double* %284
%285 = load double*, double** %5
%286 = getelementptr inbounds double, double* %285, i64 10
%287 = load double, double* %286
%288 = load double, double* %9
%289 = fdiv double %287, %288
%290 = load double*, double** %5
%291 = getelementptr inbounds double, double* %290, i64 10
store double %289, double* %291
%292 = load double*, double** %6
%293 = getelementptr inbounds double, double* %292, i64 0
%294 = load double, double* %293
%295 = load double*, double** %5
%296 = getelementptr inbounds double, double* %295, i64 3
store double %294, double* %296
%297 = load double*, double** %6
%298 = getelementptr inbounds double, double* %297, i64 1
%299 = load double, double* %298
%300 = load double*, double** %5
%301 = getelementptr inbounds double, double* %300, i64 7
store double %299, double* %301
%302 = load double*, double** %6
%303 = getelementptr inbounds double, double* %302, i64 2
%304 = load double, double* %303
%305 = load double*, double** %5
%306 = getelementptr inbounds double, double* %305, i64 11
store double %304, double* %306
%307 = load double*, double** %5
%308 = getelementptr inbounds double, double* %307, i64 15
store double 1.000000e+00, double* %308
ret void
}

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