#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 */
int /*<<< orphan*/ assert(int);
void inv3x3(double A[9], double Ainv[9]) {
  double detA = A[0] * A[4] * A[8] + A[3] * A[7] * A[2] + A[6] * A[1] * A[5] -
                A[6] * A[4] * A[2] - A[7] * A[5] * A[0] - A[8] * A[3] * A[1];
  assert(detA != 0.f);
  Ainv[0] = (A[4] * A[8] - A[5] * A[7]) / detA;
  Ainv[1] = (A[2] * A[7] - A[1] * A[8]) / detA;
  Ainv[2] = (A[1] * A[5] - A[2] * A[4]) / detA;
  Ainv[3] = (A[5] * A[6] - A[3] * A[8]) / detA;
  Ainv[4] = (A[0] * A[8] - A[2] * A[6]) / detA;
  Ainv[5] = (A[2] * A[3] - A[0] * A[5]) / detA;
  Ainv[6] = (A[3] * A[7] - A[4] * A[6]) / detA;
  Ainv[7] = (A[1] * A[6] - A[0] * A[7]) / detA;
  Ainv[8] = (A[0] * A[4] - A[1] * A[3]) / detA;
}


x86 assembly (clang, -O0):
<inv3x3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x38(%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    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x40(%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    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%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
divsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x40(%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    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%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
divsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%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
divsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x20(%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
divsd  -0x18(%rbp),%xmm0
mov    -0x10(%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  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x38(%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    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%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    -0x10(%rbp),%rax
movsd  %xmm0,0x40(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inv3x3>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
movsd  0x20(%rdi),%xmm1
movsd  (%rdi),%xmm2
movsd  0x8(%rdi),%xmm8
movsd  0x38(%rdi),%xmm3
movsd  0x30(%rdi),%xmm9
movapd %xmm9,%xmm4
mulsd  %xmm8,%xmm4
movsd  0x28(%rdi),%xmm5
mulsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm1,%xmm2
movsd  0x40(%rdi),%xmm6
movsd  0x18(%rdi),%xmm0
movapd %xmm0,%xmm7
mulsd  %xmm3,%xmm7
movsd  0x10(%rdi),%xmm3
mulsd  %xmm3,%xmm7
mulsd  %xmm6,%xmm2
addsd  %xmm7,%xmm2
addsd  %xmm2,%xmm4
mulsd  %xmm9,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mulsd  %xmm6,%xmm0
mulsd  %xmm8,%xmm0
subsd  %xmm0,%xmm4
movsd  %xmm4,(%rsp)
xorpd  %xmm0,%xmm0
cmpneqsd %xmm4,%xmm0
movq   %xmm0,%rdi
and    $0x1,%edi
call   1030 <assert@plt>
movsd  0x20(%rbx),%xmm0
movsd  0x38(%rbx),%xmm1
mulsd  0x28(%rbx),%xmm1
mulsd  0x40(%rbx),%xmm0
subsd  %xmm1,%xmm0
movsd  (%rsp),%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r14)
movsd  0x40(%rbx),%xmm0
mulsd  0x8(%rbx),%xmm0
movsd  0x10(%rbx),%xmm1
mulsd  0x38(%rbx),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r14)
movsd  0x8(%rbx),%xmm0
movsd  0x20(%rbx),%xmm1
mulsd  0x10(%rbx),%xmm1
mulsd  0x28(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x28(%rbx),%xmm0
movsd  0x40(%rbx),%xmm1
mulsd  0x18(%rbx),%xmm1
mulsd  0x30(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x18(%r14)
movsd  0x30(%rbx),%xmm0
mulsd  0x10(%rbx),%xmm0
movsd  (%rbx),%xmm1
mulsd  0x40(%rbx),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%r14)
movsd  0x10(%rbx),%xmm0
movsd  0x28(%rbx),%xmm1
mulsd  (%rbx),%xmm1
mulsd  0x18(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x28(%r14)
movsd  0x18(%rbx),%xmm0
movsd  0x30(%rbx),%xmm1
mulsd  0x20(%rbx),%xmm1
mulsd  0x38(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x30(%r14)
movsd  0x38(%rbx),%xmm0
mulsd  (%rbx),%xmm0
movsd  0x8(%rbx),%xmm1
mulsd  0x30(%rbx),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,0x38(%r14)
movsd  (%rbx),%xmm0
movsd  0x18(%rbx),%xmm1
mulsd  0x8(%rbx),%xmm1
mulsd  0x20(%rbx),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @inv3x3(double* nocapture %0, double* nocapture writeonly %1) {
%3 = load double, double* %0
%4 = getelementptr inbounds double, double* %0, i64 4
%5 = load double, double* %4
%6 = fmul double %3, %5
%7 = getelementptr inbounds double, double* %0, i64 8
%8 = load double, double* %7
%9 = getelementptr inbounds double, double* %0, i64 3
%10 = load double, double* %9
%11 = getelementptr inbounds double, double* %0, i64 7
%12 = load double, double* %11
%13 = fmul double %10, %12
%14 = getelementptr inbounds double, double* %0, i64 2
%15 = load double, double* %14
%16 = fmul double %13, %15
%17 = tail call double @llvm.fmuladd.f64(double %6, double %8, double %16)
%18 = getelementptr inbounds double, double* %0, i64 6
%19 = load double, double* %18
%20 = getelementptr inbounds double, double* %0, i64 1
%21 = load double, double* %20
%22 = fmul double %19, %21
%23 = getelementptr inbounds double, double* %0, i64 5
%24 = load double, double* %23
%25 = tail call double @llvm.fmuladd.f64(double %22, double %24, double %17)
%26 = fneg double %19
%27 = fmul double %5, %26
%28 = tail call double @llvm.fmuladd.f64(double %27, double %15, double %25)
%29 = fneg double %12
%30 = fmul double %24, %29
%31 = tail call double @llvm.fmuladd.f64(double %30, double %3, double %28)
%32 = fneg double %8
%33 = fmul double %10, %32
%34 = tail call double @llvm.fmuladd.f64(double %33, double %21, double %31)
%35 = fcmp une double %34, 0.000000e+00
%36 = zext i1 %35 to i32
%37 = tail call i32 @assert(i32 %36)
%38 = load double, double* %4
%39 = load double, double* %7
%40 = load double, double* %23
%41 = load double, double* %11
%42 = fneg double %40
%43 = fmul double %41, %42
%44 = tail call double @llvm.fmuladd.f64(double %38, double %39, double %43)
%45 = fdiv double %44, %34
store double %45, double* %1
%46 = load double, double* %14
%47 = load double, double* %11
%48 = load double, double* %20
%49 = load double, double* %7
%50 = fneg double %48
%51 = fmul double %49, %50
%52 = tail call double @llvm.fmuladd.f64(double %46, double %47, double %51)
%53 = fdiv double %52, %34
%54 = getelementptr inbounds double, double* %1, i64 1
store double %53, double* %54
%55 = load double, double* %20
%56 = load double, double* %23
%57 = load double, double* %14
%58 = load double, double* %4
%59 = fneg double %57
%60 = fmul double %58, %59
%61 = tail call double @llvm.fmuladd.f64(double %55, double %56, double %60)
%62 = fdiv double %61, %34
%63 = getelementptr inbounds double, double* %1, i64 2
store double %62, double* %63
%64 = load double, double* %23
%65 = load double, double* %18
%66 = load double, double* %9
%67 = load double, double* %7
%68 = fneg double %66
%69 = fmul double %67, %68
%70 = tail call double @llvm.fmuladd.f64(double %64, double %65, double %69)
%71 = fdiv double %70, %34
%72 = getelementptr inbounds double, double* %1, i64 3
store double %71, double* %72
%73 = load double, double* %0
%74 = load double, double* %7
%75 = load double, double* %14
%76 = load double, double* %18
%77 = fneg double %75
%78 = fmul double %76, %77
%79 = tail call double @llvm.fmuladd.f64(double %73, double %74, double %78)
%80 = fdiv double %79, %34
%81 = getelementptr inbounds double, double* %1, i64 4
store double %80, double* %81
%82 = load double, double* %14
%83 = load double, double* %9
%84 = load double, double* %0
%85 = load double, double* %23
%86 = fneg double %84
%87 = fmul double %85, %86
%88 = tail call double @llvm.fmuladd.f64(double %82, double %83, double %87)
%89 = fdiv double %88, %34
%90 = getelementptr inbounds double, double* %1, i64 5
store double %89, double* %90
%91 = load double, double* %9
%92 = load double, double* %11
%93 = load double, double* %4
%94 = load double, double* %18
%95 = fneg double %93
%96 = fmul double %94, %95
%97 = tail call double @llvm.fmuladd.f64(double %91, double %92, double %96)
%98 = fdiv double %97, %34
%99 = getelementptr inbounds double, double* %1, i64 6
store double %98, double* %99
%100 = load double, double* %20
%101 = load double, double* %18
%102 = load double, double* %0
%103 = load double, double* %11
%104 = fneg double %102
%105 = fmul double %103, %104
%106 = tail call double @llvm.fmuladd.f64(double %100, double %101, double %105)
%107 = fdiv double %106, %34
%108 = getelementptr inbounds double, double* %1, i64 7
store double %107, double* %108
%109 = load double, double* %0
%110 = load double, double* %4
%111 = load double, double* %20
%112 = load double, double* %9
%113 = fneg double %111
%114 = fmul double %112, %113
%115 = tail call double @llvm.fmuladd.f64(double %109, double %110, double %114)
%116 = fdiv double %115, %34
%117 = getelementptr inbounds double, double* %1, i64 8
store double %116, double* %117
ret void
}