void kramer3(double A[3][3], double b[3], double x[3]) {
  double det;
  double determinant();
  det = 1.0 / determinant(A, 3);
  x[0] = (b[0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1]) -
          b[1] * (A[0][1] * A[2][2] - A[0][2] * A[2][1]) +
          b[2] * (A[0][1] * A[1][2] - A[0][2] * A[1][1])) *
         det;
  x[1] = -(b[0] * (A[1][0] * A[2][2] - A[1][2] * A[2][0]) -
           b[1] * (A[0][0] * A[2][2] - A[0][2] * A[2][0]) +
           b[2] * (A[0][0] * A[1][2] - A[0][2] * A[1][0])) *
         det;
  x[2] = (b[0] * (A[1][0] * A[2][1] - A[1][1] * A[2][0]) -
          b[1] * (A[0][0] * A[2][1] - A[0][1] * A[2][0]) +
          b[2] * (A[0][0] * A[1][1] - A[0][1] * A[1][0])) *
         det;
}


x86 assembly (clang, -O0):
<kramer3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    $0x3,%esi
mov    $0x0,%al
call   1030 <determinant@plt>
movaps %xmm0,%xmm1
movsd  0xec1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x38(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm5
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm4
mov    -0x8(%rbp),%rax
mulsd  0x38(%rax),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm4
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm5
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm4
mov    -0x8(%rbp),%rax
mulsd  0x30(%rax),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm4
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm3
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm5
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm4
mov    -0x8(%rbp),%rax
mulsd  0x30(%rax),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm4
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm3
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kramer3>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
mov    $0x3,%esi
xor    %eax,%eax
call   1030 <determinant@plt>
movsd  0xece(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x20(%rbx),%xmm0
movsd  0x40(%rbx),%xmm2
movsd  0x28(%rbx),%xmm3
movsd  0x38(%rbx),%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm3,%xmm5
movapd %xmm0,%xmm6
mulsd  %xmm2,%xmm6
subsd  %xmm5,%xmm6
movsd  0x8(%rbx),%xmm5
movsd  0x10(%rbx),%xmm7
mulsd  %xmm7,%xmm4
mulsd  %xmm5,%xmm2
subsd  %xmm4,%xmm2
mulsd  0x8(%r15),%xmm2
mulsd  (%r15),%xmm6
subsd  %xmm2,%xmm6
mulsd  %xmm7,%xmm0
mulsd  %xmm3,%xmm5
subsd  %xmm0,%xmm5
mulsd  0x10(%r15),%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm1,%xmm5
movsd  %xmm5,(%r14)
movsd  0x18(%rbx),%xmm0
movsd  0x40(%rbx),%xmm2
movsd  0x30(%rbx),%xmm3
movapd %xmm3,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm2,%xmm5
movsd  (%rbx),%xmm6
movsd  0x10(%rbx),%xmm7
mulsd  %xmm7,%xmm3
mulsd  %xmm6,%xmm2
subsd  %xmm3,%xmm2
movsd  0x28(%rbx),%xmm3
mulsd  %xmm3,%xmm4
mulsd  0x8(%r15),%xmm2
subsd  %xmm4,%xmm5
mulsd  (%r15),%xmm5
mulsd  %xmm7,%xmm0
mulsd  %xmm3,%xmm6
subsd  %xmm0,%xmm6
mulsd  0x10(%r15),%xmm6
subsd  %xmm2,%xmm5
addsd  %xmm5,%xmm6
xorpd  0xe04(%rip),%xmm6
mulsd  %xmm1,%xmm6
movsd  %xmm6,0x8(%r14)
movsd  0x18(%rbx),%xmm0
movsd  0x38(%rbx),%xmm2
movsd  0x30(%rbx),%xmm3
movapd %xmm3,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm2,%xmm5
movsd  (%rbx),%xmm6
movsd  0x8(%rbx),%xmm7
mulsd  %xmm7,%xmm3
mulsd  %xmm6,%xmm2
subsd  %xmm3,%xmm2
movsd  0x20(%rbx),%xmm3
mulsd  %xmm3,%xmm4
mulsd  0x8(%r15),%xmm2
subsd  %xmm4,%xmm5
mulsd  (%r15),%xmm5
mulsd  %xmm7,%xmm0
mulsd  %xmm3,%xmm6
subsd  %xmm0,%xmm6
mulsd  0x10(%r15),%xmm6
subsd  %xmm2,%xmm5
addsd  %xmm5,%xmm6
mulsd  %xmm1,%xmm6
movsd  %xmm6,0x10(%r14)
pop    %rbx
pop    %r14
pop    %r15
ret

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

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