void build_rotmatrix(double m[4][4], double q[4]) {
  m[0][0] = 1.0 - 2.0 * (q[1] * q[1] + q[2] * q[2]);
  m[0][1] = 2.0 * (q[0] * q[1] - q[2] * q[3]);
  m[0][2] = 2.0 * (q[2] * q[0] + q[1] * q[3]);
  m[0][3] = 0.0;
  m[1][0] = 2.0 * (q[0] * q[1] + q[2] * q[3]);
  m[1][1] = 1.0 - 2.0 * (q[2] * q[2] + q[0] * q[0]);
  m[1][2] = 2.0 * (q[1] * q[2] - q[0] * q[3]);
  m[1][3] = 0.0;
  m[2][0] = 2.0 * (q[2] * q[0] - q[1] * q[3]);
  m[2][1] = 2.0 * (q[1] * q[2] + q[0] * q[3]);
  m[2][2] = 1.0 - 2.0 * (q[1] * q[1] + q[0] * q[0]);
  m[2][3] = 0.0;
  m[3][0] = 0.0;
  m[3][1] = 0.0;
  m[3][2] = 0.0;
  m[3][3] = 1.0;
}


x86 assembly (clang, -O0):
<build_rotmatrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xebc(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe6e(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe2e(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xde2(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xd97(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xd48(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xce5(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xca5(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xc5a(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x58(%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    -0x8(%rbp),%rax
movsd  0xc11(%rip),%xmm0
movsd  %xmm0,0x78(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<build_rotmatrix>:
movsd  0x8(%rsi),%xmm1
movsd  0x10(%rsi),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
movsd  0xede(%rip),%xmm0
movapd %xmm0,%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi)
movsd  0x18(%rsi),%xmm1
mulsd  0x10(%rsi),%xmm1
movsd  (%rsi),%xmm2
mulsd  0x8(%rsi),%xmm2
subsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,0x8(%rdi)
movsd  0x8(%rsi),%xmm1
movsd  0x10(%rsi),%xmm2
mulsd  0x18(%rsi),%xmm1
mulsd  (%rsi),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,0x10(%rdi)
movq   $0x0,0x18(%rdi)
movsd  0x10(%rsi),%xmm1
mulsd  0x18(%rsi),%xmm1
movsd  (%rsi),%xmm2
mulsd  0x8(%rsi),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,0x20(%rdi)
movsd  (%rsi),%xmm1
movsd  0x10(%rsi),%xmm2
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x28(%rdi)
movsd  0x8(%rsi),%xmm1
movsd  0x18(%rsi),%xmm2
mulsd  (%rsi),%xmm2
mulsd  0x10(%rsi),%xmm1
subsd  %xmm2,%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,0x30(%rdi)
movq   $0x0,0x38(%rdi)
movsd  0x18(%rsi),%xmm1
mulsd  0x8(%rsi),%xmm1
movsd  0x10(%rsi),%xmm2
mulsd  (%rsi),%xmm2
subsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,0x40(%rdi)
movsd  (%rsi),%xmm1
movsd  0x8(%rsi),%xmm2
mulsd  0x18(%rsi),%xmm1
mulsd  0x10(%rsi),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,0x48(%rdi)
movsd  (%rsi),%xmm1
movsd  0x8(%rsi),%xmm2
mulsd  %xmm1,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x50(%rdi)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x58(%rdi)
movupd %xmm0,0x68(%rdi)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x78(%rdi)
ret

LLVM IR (-O0):
define void @build_rotmatrix([4 x double]* %0, double* %1) {
%3 = alloca [4 x double]*
%4 = alloca double*
store [4 x double]* %0, [4 x double]** %3
store double* %1, double** %4
%5 = load double*, double** %4
%6 = getelementptr inbounds double, double* %5, i64 1
%7 = load double, double* %6
%8 = load double*, double** %4
%9 = getelementptr inbounds double, double* %8, i64 1
%10 = load double, double* %9
%11 = load double*, double** %4
%12 = getelementptr inbounds double, double* %11, i64 2
%13 = load double, double* %12
%14 = load double*, double** %4
%15 = getelementptr inbounds double, double* %14, i64 2
%16 = load double, double* %15
%17 = fmul double %13, %16
%18 = call double @llvm.fmuladd.f64(double %7, double %10, double %17)
%19 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %18, double 1.000000e+00)
%20 = load [4 x double]*, [4 x double]** %3
%21 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0
%22 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 0, i64 0
store double %19, double* %22
%23 = load double*, double** %4
%24 = getelementptr inbounds double, double* %23, i64 0
%25 = load double, double* %24
%26 = load double*, double** %4
%27 = getelementptr inbounds double, double* %26, i64 1
%28 = load double, double* %27
%29 = load double*, double** %4
%30 = getelementptr inbounds double, double* %29, i64 2
%31 = load double, double* %30
%32 = load double*, double** %4
%33 = getelementptr inbounds double, double* %32, i64 3
%34 = load double, double* %33
%35 = fmul double %31, %34
%36 = fneg double %35
%37 = call double @llvm.fmuladd.f64(double %25, double %28, double %36)
%38 = fmul double 2.000000e+00, %37
%39 = load [4 x double]*, [4 x double]** %3
%40 = getelementptr inbounds [4 x double], [4 x double]* %39, i64 0
%41 = getelementptr inbounds [4 x double], [4 x double]* %40, i64 0, i64 1
store double %38, double* %41
%42 = load double*, double** %4
%43 = getelementptr inbounds double, double* %42, i64 2
%44 = load double, double* %43
%45 = load double*, double** %4
%46 = getelementptr inbounds double, double* %45, i64 0
%47 = load double, double* %46
%48 = load double*, double** %4
%49 = getelementptr inbounds double, double* %48, i64 1
%50 = load double, double* %49
%51 = load double*, double** %4
%52 = getelementptr inbounds double, double* %51, i64 3
%53 = load double, double* %52
%54 = fmul double %50, %53
%55 = call double @llvm.fmuladd.f64(double %44, double %47, double %54)
%56 = fmul double 2.000000e+00, %55
%57 = load [4 x double]*, [4 x double]** %3
%58 = getelementptr inbounds [4 x double], [4 x double]* %57, i64 0
%59 = getelementptr inbounds [4 x double], [4 x double]* %58, i64 0, i64 2
store double %56, double* %59
%60 = load [4 x double]*, [4 x double]** %3
%61 = getelementptr inbounds [4 x double], [4 x double]* %60, i64 0
%62 = getelementptr inbounds [4 x double], [4 x double]* %61, i64 0, i64 3
store double 0.000000e+00, double* %62
%63 = load double*, double** %4
%64 = getelementptr inbounds double, double* %63, i64 0
%65 = load double, double* %64
%66 = load double*, double** %4
%67 = getelementptr inbounds double, double* %66, i64 1
%68 = load double, double* %67
%69 = load double*, double** %4
%70 = getelementptr inbounds double, double* %69, i64 2
%71 = load double, double* %70
%72 = load double*, double** %4
%73 = getelementptr inbounds double, double* %72, i64 3
%74 = load double, double* %73
%75 = fmul double %71, %74
%76 = call double @llvm.fmuladd.f64(double %65, double %68, double %75)
%77 = fmul double 2.000000e+00, %76
%78 = load [4 x double]*, [4 x double]** %3
%79 = getelementptr inbounds [4 x double], [4 x double]* %78, i64 1
%80 = getelementptr inbounds [4 x double], [4 x double]* %79, i64 0, i64 0
store double %77, double* %80
%81 = load double*, double** %4
%82 = getelementptr inbounds double, double* %81, i64 2
%83 = load double, double* %82
%84 = load double*, double** %4
%85 = getelementptr inbounds double, double* %84, i64 2
%86 = load double, double* %85
%87 = load double*, double** %4
%88 = getelementptr inbounds double, double* %87, i64 0
%89 = load double, double* %88
%90 = load double*, double** %4
%91 = getelementptr inbounds double, double* %90, i64 0
%92 = load double, double* %91
%93 = fmul double %89, %92
%94 = call double @llvm.fmuladd.f64(double %83, double %86, double %93)
%95 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %94, double 1.000000e+00)
%96 = load [4 x double]*, [4 x double]** %3
%97 = getelementptr inbounds [4 x double], [4 x double]* %96, i64 1
%98 = getelementptr inbounds [4 x double], [4 x double]* %97, i64 0, i64 1
store double %95, double* %98
%99 = load double*, double** %4
%100 = getelementptr inbounds double, double* %99, i64 1
%101 = load double, double* %100
%102 = load double*, double** %4
%103 = getelementptr inbounds double, double* %102, i64 2
%104 = load double, double* %103
%105 = load double*, double** %4
%106 = getelementptr inbounds double, double* %105, i64 0
%107 = load double, double* %106
%108 = load double*, double** %4
%109 = getelementptr inbounds double, double* %108, i64 3
%110 = load double, double* %109
%111 = fmul double %107, %110
%112 = fneg double %111
%113 = call double @llvm.fmuladd.f64(double %101, double %104, double %112)
%114 = fmul double 2.000000e+00, %113
%115 = load [4 x double]*, [4 x double]** %3
%116 = getelementptr inbounds [4 x double], [4 x double]* %115, i64 1
%117 = getelementptr inbounds [4 x double], [4 x double]* %116, i64 0, i64 2
store double %114, double* %117
%118 = load [4 x double]*, [4 x double]** %3
%119 = getelementptr inbounds [4 x double], [4 x double]* %118, i64 1
%120 = getelementptr inbounds [4 x double], [4 x double]* %119, i64 0, i64 3
store double 0.000000e+00, double* %120
%121 = load double*, double** %4
%122 = getelementptr inbounds double, double* %121, i64 2
%123 = load double, double* %122
%124 = load double*, double** %4
%125 = getelementptr inbounds double, double* %124, i64 0
%126 = load double, double* %125
%127 = load double*, double** %4
%128 = getelementptr inbounds double, double* %127, i64 1
%129 = load double, double* %128
%130 = load double*, double** %4
%131 = getelementptr inbounds double, double* %130, i64 3
%132 = load double, double* %131
%133 = fmul double %129, %132
%134 = fneg double %133
%135 = call double @llvm.fmuladd.f64(double %123, double %126, double %134)
%136 = fmul double 2.000000e+00, %135
%137 = load [4 x double]*, [4 x double]** %3
%138 = getelementptr inbounds [4 x double], [4 x double]* %137, i64 2
%139 = getelementptr inbounds [4 x double], [4 x double]* %138, i64 0, i64 0
store double %136, double* %139
%140 = load double*, double** %4
%141 = getelementptr inbounds double, double* %140, i64 1
%142 = load double, double* %141
%143 = load double*, double** %4
%144 = getelementptr inbounds double, double* %143, i64 2
%145 = load double, double* %144
%146 = load double*, double** %4
%147 = getelementptr inbounds double, double* %146, i64 0
%148 = load double, double* %147
%149 = load double*, double** %4
%150 = getelementptr inbounds double, double* %149, i64 3
%151 = load double, double* %150
%152 = fmul double %148, %151
%153 = call double @llvm.fmuladd.f64(double %142, double %145, double %152)
%154 = fmul double 2.000000e+00, %153
%155 = load [4 x double]*, [4 x double]** %3
%156 = getelementptr inbounds [4 x double], [4 x double]* %155, i64 2
%157 = getelementptr inbounds [4 x double], [4 x double]* %156, i64 0, i64 1
store double %154, double* %157
%158 = load double*, double** %4
%159 = getelementptr inbounds double, double* %158, i64 1
%160 = load double, double* %159
%161 = load double*, double** %4
%162 = getelementptr inbounds double, double* %161, i64 1
%163 = load double, double* %162
%164 = load double*, double** %4
%165 = getelementptr inbounds double, double* %164, i64 0
%166 = load double, double* %165
%167 = load double*, double** %4
%168 = getelementptr inbounds double, double* %167, i64 0
%169 = load double, double* %168
%170 = fmul double %166, %169
%171 = call double @llvm.fmuladd.f64(double %160, double %163, double %170)
%172 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %171, double 1.000000e+00)
%173 = load [4 x double]*, [4 x double]** %3
%174 = getelementptr inbounds [4 x double], [4 x double]* %173, i64 2
%175 = getelementptr inbounds [4 x double], [4 x double]* %174, i64 0, i64 2
store double %172, double* %175
%176 = load [4 x double]*, [4 x double]** %3
%177 = getelementptr inbounds [4 x double], [4 x double]* %176, i64 2
%178 = getelementptr inbounds [4 x double], [4 x double]* %177, i64 0, i64 3
store double 0.000000e+00, double* %178
%179 = load [4 x double]*, [4 x double]** %3
%180 = getelementptr inbounds [4 x double], [4 x double]* %179, i64 3
%181 = getelementptr inbounds [4 x double], [4 x double]* %180, i64 0, i64 0
store double 0.000000e+00, double* %181
%182 = load [4 x double]*, [4 x double]** %3
%183 = getelementptr inbounds [4 x double], [4 x double]* %182, i64 3
%184 = getelementptr inbounds [4 x double], [4 x double]* %183, i64 0, i64 1
store double 0.000000e+00, double* %184
%185 = load [4 x double]*, [4 x double]** %3
%186 = getelementptr inbounds [4 x double], [4 x double]* %185, i64 3
%187 = getelementptr inbounds [4 x double], [4 x double]* %186, i64 0, i64 2
store double 0.000000e+00, double* %187
%188 = load [4 x double]*, [4 x double]** %3
%189 = getelementptr inbounds [4 x double], [4 x double]* %188, i64 3
%190 = getelementptr inbounds [4 x double], [4 x double]* %189, i64 0, i64 3
store double 1.000000e+00, double* %190
ret void
}

LLVM IR (-O2):
define void @build_rotmatrix([4 x double]* nocapture writeonly %0, double* nocapture %1) {
%3 = getelementptr inbounds double, double* %1, i64 1
%4 = load double, double* %3
%5 = getelementptr inbounds double, double* %1, i64 2
%6 = load double, double* %5
%7 = fmul double %6, %6
%8 = tail call double @llvm.fmuladd.f64(double %4, double %4, double %7)
%9 = tail call double @llvm.fmuladd.f64(double %8, double -2.000000e+00, double 1.000000e+00)
%10 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 0
store double %9, double* %10
%11 = load double, double* %1
%12 = load double, double* %3
%13 = load double, double* %5
%14 = getelementptr inbounds double, double* %1, i64 3
%15 = load double, double* %14
%16 = fneg double %13
%17 = fmul double %15, %16
%18 = tail call double @llvm.fmuladd.f64(double %11, double %12, double %17)
%19 = fmul double %18, 2.000000e+00
%20 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 1
store double %19, double* %20
%21 = load double, double* %5
%22 = load double, double* %1
%23 = load double, double* %3
%24 = load double, double* %14
%25 = fmul double %23, %24
%26 = tail call double @llvm.fmuladd.f64(double %21, double %22, double %25)
%27 = fmul double %26, 2.000000e+00
%28 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 2
store double %27, double* %28
%29 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 3
store double 0.000000e+00, double* %29
%30 = load double, double* %1
%31 = load double, double* %3
%32 = load double, double* %5
%33 = load double, double* %14
%34 = fmul double %32, %33
%35 = tail call double @llvm.fmuladd.f64(double %30, double %31, double %34)
%36 = fmul double %35, 2.000000e+00
%37 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 0
store double %36, double* %37
%38 = load double, double* %5
%39 = load double, double* %1
%40 = fmul double %39, %39
%41 = tail call double @llvm.fmuladd.f64(double %38, double %38, double %40)
%42 = tail call double @llvm.fmuladd.f64(double %41, double -2.000000e+00, double 1.000000e+00)
%43 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 1
store double %42, double* %43
%44 = load double, double* %3
%45 = load double, double* %5
%46 = load double, double* %1
%47 = load double, double* %14
%48 = fneg double %46
%49 = fmul double %47, %48
%50 = tail call double @llvm.fmuladd.f64(double %44, double %45, double %49)
%51 = fmul double %50, 2.000000e+00
%52 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 2
store double %51, double* %52
%53 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 3
store double 0.000000e+00, double* %53
%54 = load double, double* %5
%55 = load double, double* %1
%56 = load double, double* %3
%57 = load double, double* %14
%58 = fneg double %56
%59 = fmul double %57, %58
%60 = tail call double @llvm.fmuladd.f64(double %54, double %55, double %59)
%61 = fmul double %60, 2.000000e+00
%62 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 0
store double %61, double* %62
%63 = load double, double* %3
%64 = load double, double* %5
%65 = load double, double* %1
%66 = load double, double* %14
%67 = fmul double %65, %66
%68 = tail call double @llvm.fmuladd.f64(double %63, double %64, double %67)
%69 = fmul double %68, 2.000000e+00
%70 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 1
store double %69, double* %70
%71 = load double, double* %3
%72 = load double, double* %1
%73 = fmul double %72, %72
%74 = tail call double @llvm.fmuladd.f64(double %71, double %71, double %73)
%75 = tail call double @llvm.fmuladd.f64(double %74, double -2.000000e+00, double 1.000000e+00)
%76 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 2
store double %75, double* %76
%77 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 3
%78 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 3
%79 = bitcast double* %77 to i8*
store double 1.000000e+00, double* %78
ret void
}