#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 */
typedef float const *matA;

/* Variables and functions */
float MatDet3by3(float *);
void MatInv3by3(const float *matA, float *matB) {
  float det = MatDet3by3((float *)matA);
  *(matB) = (-(*((matA + 2 * 3) + 1)) * (*((matA + 1 * 3) + 2)) +
             (*((matA + 1 * 3) + 1)) * (*((matA + 2 * 3) + 2))) /
            det;
  (*(matB + 1)) = (-(*((matA) + 1)) * (*((matA + 2 * 3) + 2)) +
                   (*((matA) + 2)) * (*((matA + 2 * 3) + 1))) /
                  det;
  (*(matB + 2)) = ((*((matA) + 1)) * (*((matA + 1 * 3) + 2)) -
                   (*((matA) + 2)) * (*((matA + 1 * 3) + 1))) /
                  det;
  (*(matB + 3)) = ((*((matA + 2 * 3))) * (*((matA + 3) + 2)) -
                   (*((matA + 3))) * (*((matA + 2 * 3) + 2))) /
                  det;
  (*((matB + 3) + 1)) = (-(*((matA + 2 * 3))) * (*((matA) + 2)) +
                         (*((matA)) * (*((matA + 2 * 3) + 2)))) /
                        det;
  (*((matB + 3) + 2)) = ((*((matA + 3))) * (*((matA) + 2)) -
                         (*((matA)) * (*((matA + 1 * 3) + 2)))) /
                        det;
  (*(matB + 2 * 3)) = (-(*((matA + 2 * 3))) * (*((matA + 3) + 1)) +
                       (*((matA + 3))) * (*((matA + 2 * 3) + 1))) /
                      det;
  (*((matB + 2 * 3) + 1)) = ((*((matA + 2 * 3))) * (*((matA) + 1)) -
                             (*((matA))) * (*((matA + 2 * 3) + 1))) /
                            det;
  (*((matB + 2 * 3) + 2)) = (-(*((matA + 1 * 3))) * (*((matA) + 1)) +
                             (*((matA))) * (*((matA + 3) + 1))) /
                            det;
}


x86 assembly (clang, -O0):
<MatInv3by3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <MatDet3by3@plt>
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatInv3by3>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <MatDet3by3@plt>
movss  0x10(%rbx),%xmm1
movss  0x1c(%rbx),%xmm2
mulss  0x20(%rbx),%xmm1
mulss  0x14(%rbx),%xmm2
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x8(%rbx),%xmm1
mulss  0x1c(%rbx),%xmm1
movss  0x4(%rbx),%xmm2
mulss  0x20(%rbx),%xmm2
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x4(%rbx),%xmm1
movss  0x10(%rbx),%xmm2
mulss  0x8(%rbx),%xmm2
mulss  0x14(%rbx),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%r14)
movss  0x18(%rbx),%xmm1
movss  0x20(%rbx),%xmm2
mulss  0xc(%rbx),%xmm2
mulss  0x14(%rbx),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%r14)
movss  (%rbx),%xmm1
mulss  0x20(%rbx),%xmm1
movss  0x18(%rbx),%xmm2
mulss  0x8(%rbx),%xmm2
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%r14)
movss  0xc(%rbx),%xmm1
movss  0x14(%rbx),%xmm2
mulss  (%rbx),%xmm2
mulss  0x8(%rbx),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x14(%r14)
movss  0xc(%rbx),%xmm1
movss  0x18(%rbx),%xmm2
mulss  0x1c(%rbx),%xmm1
mulss  0x10(%rbx),%xmm2
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x18(%r14)
movss  0x1c(%rbx),%xmm1
mulss  (%rbx),%xmm1
movss  0x18(%rbx),%xmm2
mulss  0x4(%rbx),%xmm2
subss  %xmm1,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r14)
movss  (%rbx),%xmm1
movss  0xc(%rbx),%xmm2
mulss  0x10(%rbx),%xmm1
mulss  0x4(%rbx),%xmm2
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x20(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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