#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 mat3_det(double **);
void mat3_inv(double out[3][3], double in[3][3]) {
  double det;
  det = mat3_det(in);
  out[0][0] = (in[1][1] * in[2][2] - in[2][1] * in[1][2]) / det;
  out[0][1] = (in[0][2] * in[2][1] - in[2][2] * in[0][1]) / det;
  out[0][2] = (in[0][1] * in[1][2] - in[1][1] * in[0][2]) / det;
  out[1][0] = (in[1][2] * in[2][0] - in[2][2] * in[1][0]) / det;
  out[1][1] = (in[0][0] * in[2][2] - in[2][0] * in[0][2]) / det;
  out[1][2] = (in[0][2] * in[1][0] - in[1][2] * in[0][0]) / det;
  out[2][0] = (in[1][0] * in[2][1] - in[2][0] * in[1][1]) / det;
  out[2][1] = (in[0][1] * in[2][0] - in[2][1] * in[0][0]) / det;
  out[2][2] = (in[0][0] * in[1][1] - in[1][0] * in[0][1]) / det;
}


x86 assembly (clang, -O0):
<mat3_inv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <mat3_det@plt>
movsd  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x28(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat3_inv>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
mov    %rsi,%rdi
call   1030 <mat3_det@plt>
movsd  0x20(%rbx),%xmm1
movsd  0x28(%rbx),%xmm2
mulsd  0x38(%rbx),%xmm2
mulsd  0x40(%rbx),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  0x8(%rbx),%xmm1
mulsd  0x40(%rbx),%xmm1
movsd  0x10(%rbx),%xmm2
mulsd  0x38(%rbx),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r14)
movsd  0x8(%rbx),%xmm1
movsd  0x10(%rbx),%xmm2
mulsd  0x20(%rbx),%xmm2
mulsd  0x28(%rbx),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14)
movsd  0x18(%rbx),%xmm1
movsd  0x28(%rbx),%xmm2
mulsd  0x40(%rbx),%xmm1
mulsd  0x30(%rbx),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%r14)
movsd  0x10(%rbx),%xmm1
mulsd  0x30(%rbx),%xmm1
movsd  (%rbx),%xmm2
mulsd  0x40(%rbx),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x20(%r14)
movsd  (%rbx),%xmm1
movsd  0x10(%rbx),%xmm2
mulsd  0x28(%rbx),%xmm1
mulsd  0x18(%rbx),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x28(%r14)
movsd  0x18(%rbx),%xmm1
movsd  0x20(%rbx),%xmm2
mulsd  0x30(%rbx),%xmm2
mulsd  0x38(%rbx),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%r14)
movsd  (%rbx),%xmm1
mulsd  0x38(%rbx),%xmm1
movsd  0x8(%rbx),%xmm2
mulsd  0x30(%rbx),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x38(%r14)
movsd  (%rbx),%xmm1
movsd  0x8(%rbx),%xmm2
mulsd  0x18(%rbx),%xmm2
mulsd  0x20(%rbx),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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