#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*/ f3x3matrixAeqI(float **);
void f3x3matrixAeqInvSymB(float A[][3], float B[][3]) {
  float fB11B22mB12B12;
  float fB12B02mB01B22;
  float fB01B12mB11B02;
  float ftmp;
  fB11B22mB12B12 = B[1][1] * B[2][2] - B[1][2] * B[1][2];
  fB12B02mB01B22 = B[1][2] * B[0][2] - B[0][1] * B[2][2];
  fB01B12mB11B02 = B[0][1] * B[1][2] - B[1][1] * B[0][2];
  ftmp = B[0][0] * fB11B22mB12B12 + B[0][1] * fB12B02mB01B22 +
         B[0][2] * fB01B12mB11B02;
  if (ftmp != 0.0F) {
    ftmp = 1.0F / ftmp;
    A[0][0] = fB11B22mB12B12 * ftmp;
    A[1][0] = A[0][1] = fB12B02mB01B22 * ftmp;
    A[2][0] = A[0][2] = fB01B12mB11B02 * ftmp;
    A[1][1] = (B[0][0] * B[2][2] - B[0][2] * B[0][2]) * ftmp;
    A[2][1] = A[1][2] = (B[0][2] * B[0][1] - B[0][0] * B[1][2]) * ftmp;
    A[2][2] = (B[0][0] * B[1][1] - B[0][1] * B[0][1]) * ftmp;
  } else {
    f3x3matrixAeqI(A);
  }
}


x86 assembly (clang, -O0):
<f3x3matrixAeqInvSymB>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x14(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1234 <f3x3matrixAeqInvSymB+0x124>
jp     1234 <f3x3matrixAeqInvSymB+0x124>
jmp    1370 <f3x3matrixAeqInvSymB+0x260>
movss  0xdc4(%rip),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x18(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
jmp    1379 <f3x3matrixAeqInvSymB+0x269>
mov    -0x8(%rbp),%rdi
call   1030 <f3x3matrixAeqI@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<f3x3matrixAeqInvSymB>:
movss  0x10(%rsi),%xmm1
movss  0x20(%rsi),%xmm5
movss  0x14(%rsi),%xmm0
movaps %xmm0,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm1,%xmm2
mulss  %xmm5,%xmm2
subss  %xmm3,%xmm2
movss  0x4(%rsi),%xmm6
movss  0x8(%rsi),%xmm4
mulss  %xmm6,%xmm5
movaps %xmm6,%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm4,%xmm0
subss  %xmm5,%xmm0
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm3
mulss  %xmm0,%xmm6
movss  (%rsi),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm6,%xmm1
mulss  %xmm3,%xmm4
addss  %xmm1,%xmm4
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm4
jne    117c <f3x3matrixAeqInvSymB+0x6c>
jnp    1210 <f3x3matrixAeqInvSymB+0x100>
movss  0xe7c(%rip),%xmm1
divss  %xmm4,%xmm1
mulss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
mulss  %xmm1,%xmm0
movss  %xmm0,0x4(%rdi)
movss  %xmm0,0xc(%rdi)
mulss  %xmm1,%xmm3
movss  %xmm3,0x8(%rdi)
movss  %xmm3,0x18(%rdi)
movss  (%rsi),%xmm0
movss  0x8(%rsi),%xmm2
mulss  %xmm2,%xmm2
mulss  0x20(%rsi),%xmm0
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x10(%rdi)
movss  0x8(%rsi),%xmm0
movss  0x14(%rsi),%xmm2
mulss  (%rsi),%xmm2
mulss  0x4(%rsi),%xmm0
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x14(%rdi)
movss  %xmm0,0x1c(%rdi)
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm2
mulss  0x10(%rsi),%xmm0
mulss  %xmm2,%xmm2
subss  %xmm2,%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x20(%rdi)
ret
jmp    1030 <f3x3matrixAeqI@plt>

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

LLVM IR (-O2):
define void @f3x3matrixAeqInvSymB([3 x float]* %0, [3 x float]* nocapture %1) {
%3 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 1, i64 1
%4 = load float, float* %3
%5 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 2, i64 2
%6 = load float, float* %5
%7 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 1, i64 2
%8 = load float, float* %7
%9 = fneg float %8
%10 = fmul float %8, %9
%11 = tail call float @llvm.fmuladd.f32(float %4, float %6, float %10)
%12 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 2
%13 = load float, float* %12
%14 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 1
%15 = load float, float* %14
%16 = fneg float %15
%17 = fmul float %6, %16
%18 = tail call float @llvm.fmuladd.f32(float %8, float %13, float %17)
%19 = fneg float %4
%20 = fmul float %13, %19
%21 = tail call float @llvm.fmuladd.f32(float %15, float %8, float %20)
%22 = getelementptr inbounds [3 x float], [3 x float]* %1, i64 0, i64 0
%23 = load float, float* %22
%24 = fmul float %15, %18
%25 = tail call float @llvm.fmuladd.f32(float %23, float %11, float %24)
%26 = tail call float @llvm.fmuladd.f32(float %13, float %21, float %25)
%27 = fcmp une float %26, 0.000000e+00
br i1 %27, label %28, label %64
28: ; preds = %2
%29 = fdiv float 1.000000e+00, %26
%30 = fmul float %11, %29
%31 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 0
store float %30, float* %31
%32 = fmul float %18, %29
%33 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 1
store float %32, float* %33
%34 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 0
store float %32, float* %34
%35 = fmul float %21, %29
%36 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 0, i64 2
store float %35, float* %36
%37 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 0
store float %35, float* %37
%38 = load float, float* %22
%39 = load float, float* %5
%40 = load float, float* %12
%41 = fneg float %40
%42 = fmul float %40, %41
%43 = tail call float @llvm.fmuladd.f32(float %38, float %39, float %42)
%44 = fmul float %29, %43
%45 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 1
store float %44, float* %45
%46 = load float, float* %12
%47 = load float, float* %14
%48 = load float, float* %22
%49 = load float, float* %7
%50 = fneg float %48
%51 = fmul float %49, %50
%52 = tail call float @llvm.fmuladd.f32(float %46, float %47, float %51)
%53 = fmul float %29, %52
%54 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 1, i64 2
store float %53, float* %54
%55 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 1
store float %53, float* %55
%56 = load float, float* %22
%57 = load float, float* %3
%58 = load float, float* %14
%59 = fneg float %58
%60 = fmul float %58, %59
%61 = tail call float @llvm.fmuladd.f32(float %56, float %57, float %60)
%62 = fmul float %29, %61
%63 = getelementptr inbounds [3 x float], [3 x float]* %0, i64 2, i64 2
store float %62, float* %63
br label %67
64: ; preds = %2
%65 = bitcast [3 x float]* %0 to float**
%66 = tail call i32 @f3x3matrixAeqI(float** %65)
br label %67
67: ; preds = %64, %28
ret void
}