int MagellanMultiplicationMatrix(MatrixA, MatrixB, MatrixC)
double MatrixA[4][4], MatrixB[4][4], MatrixC[4][4];
{
  double MatrixR[4][4];
  MatrixR[0][0] = MatrixB[0][0] * MatrixC[0][0] +
                  MatrixB[0][1] * MatrixC[1][0] + MatrixB[0][2] * MatrixC[2][0];
  MatrixR[0][1] = MatrixB[0][0] * MatrixC[0][1] +
                  MatrixB[0][1] * MatrixC[1][1] + MatrixB[0][2] * MatrixC[2][1];
  MatrixR[0][2] = MatrixB[0][0] * MatrixC[0][2] +
                  MatrixB[0][1] * MatrixC[1][2] + MatrixB[0][2] * MatrixC[2][2];
  MatrixR[1][0] = MatrixB[1][0] * MatrixC[0][0] +
                  MatrixB[1][1] * MatrixC[1][0] + MatrixB[1][2] * MatrixC[2][0];
  MatrixR[1][1] = MatrixB[1][0] * MatrixC[0][1] +
                  MatrixB[1][1] * MatrixC[1][1] + MatrixB[1][2] * MatrixC[2][1];
  MatrixR[1][2] = MatrixB[1][0] * MatrixC[0][2] +
                  MatrixB[1][1] * MatrixC[1][2] + MatrixB[1][2] * MatrixC[2][2];
  MatrixR[2][0] = MatrixB[2][0] * MatrixC[0][0] +
                  MatrixB[2][1] * MatrixC[1][0] + MatrixB[2][2] * MatrixC[2][0];
  MatrixR[2][1] = MatrixB[2][0] * MatrixC[0][1] +
                  MatrixB[2][1] * MatrixC[1][1] + MatrixB[2][2] * MatrixC[2][1];
  MatrixR[2][2] = MatrixB[2][0] * MatrixC[0][2] +
                  MatrixB[2][1] * MatrixC[1][2] + MatrixB[2][2] * MatrixC[2][2];
  MatrixR[0][3] = MatrixR[1][3] = MatrixR[2][3] = MatrixR[3][0] =
      MatrixR[3][1] = MatrixR[3][2] = 0.0;
  MatrixR[3][3] = 1.0;
  memcpy(MatrixA, MatrixR, sizeof(MatrixA));
  return (1 == 1);
}


x86 assembly (clang, -O0):
<MagellanMultiplicationMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x40(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x28(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x48(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  0x30(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x50(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xc0b(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    %rcx,(%rax)
mov    $0x1,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MagellanMultiplicationMatrix>:
movsd  (%rsi),%xmm0
movsd  0x8(%rsi),%xmm1
mulsd  0x20(%rdx),%xmm1
mulsd  (%rdx),%xmm0
movsd  0x10(%rsi),%xmm2
mulsd  0x40(%rdx),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rdi)
mov    $0x1,%eax
ret

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

LLVM IR (-O2):
define i32 @MagellanMultiplicationMatrix([4 x double]* nocapture writeonly %0, [4 x double]* nocapture %1, [4 x double]* nocapture %2) {
%4 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 0
%5 = load double, double* %4
%6 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 0, i64 0
%7 = load double, double* %6
%8 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 1
%9 = load double, double* %8
%10 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 1, i64 0
%11 = load double, double* %10
%12 = fmul double %9, %11
%13 = tail call double @llvm.fmuladd.f64(double %5, double %7, double %12)
%14 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 2
%15 = load double, double* %14
%16 = getelementptr inbounds [4 x double], [4 x double]* %2, i64 2, i64 0
%17 = load double, double* %16
%18 = tail call double @llvm.fmuladd.f64(double %15, double %17, double %13)
%19 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 0
store double %18, double* %19
ret i32 1
}