#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 int /*<<< orphan*/ invT;

/* Variables and functions */
int /*<<< orphan*/ memcpy(float *, float **, int);
float *i33(float *__restrict inverse, const float *const __restrict t) {
  const float n = t[0] * (t[4] * t[8] - t[5] * t[7]) -
                  t[1] * (t[3] * t[8] - t[5] * t[6]) +
                  t[2] * (t[3] * t[7] - t[4] * t[6]);
  float invT[3][3] = {
      {(t[4] * t[8] - t[5] * t[7]) / n, (t[2] * t[7] - t[1] * t[8]) / n,
       (t[1] * t[5] - t[2] * t[4]) / n},
      {(t[5] * t[6] - t[3] * t[8]) / n, (t[0] * t[8] - t[2] * t[6]) / n,
       (t[2] * t[3] - t[0] * t[5]) / n},
      {(t[3] * t[7] - t[4] * t[6]) / n, (t[1] * t[6] - t[0] * t[7]) / n,
       (t[0] * t[4] - t[1] * t[3]) / n},
  };
  memcpy(inverse, invT, sizeof(invT));
  return inverse;
}


x86 assembly (clang, -O0):
<i33>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm3
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm5
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm4
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm4
movd   %xmm4,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm4
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm3
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%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  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%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
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%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
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0xc(%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
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
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  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%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
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%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
movss  %xmm0,-0x24(%rbp)
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  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<i33>:
push   %rbx
sub    $0x30,%rsp
mov    %rdi,%rbx
movss  0x10(%rsi),%xmm8
movups 0x14(%rsi),%xmm2
movups (%rsi),%xmm1
movaps %xmm1,%xmm9
movss  %xmm2,%xmm9
movaps %xmm2,%xmm12
movaps %xmm2,%xmm4
movaps %xmm2,%xmm10
movaps %xmm2,%xmm14
movaps %xmm2,%xmm11
movaps %xmm2,%xmm13
movaps %xmm1,%xmm0
shufps $0x33,%xmm2,%xmm0
shufps $0x62,%xmm2,%xmm0
shufps $0x4b,%xmm2,%xmm2
movaps %xmm1,%xmm6
shufps $0x78,%xmm1,%xmm6
movaps %xmm1,%xmm5
unpckhpd %xmm1,%xmm5
movaps %xmm1,%xmm7
shufps $0xff,%xmm1,%xmm7
shufps $0xc7,%xmm8,%xmm10
shufps $0x2e,%xmm10,%xmm14
movaps 0xe85(%rip),%xmm10
mulps  %xmm9,%xmm14
xorps  %xmm10,%xmm9
shufps $0x55,%xmm12,%xmm12
mulss  %xmm9,%xmm12
shufps $0xff,%xmm4,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm12,%xmm4
movaps %xmm1,%xmm3
movsd  %xmm8,%xmm3
shufps $0xd4,%xmm1,%xmm11
shufps $0x28,%xmm11,%xmm3
pshufd $0x55,%xmm9,%xmm11
mulss  %xmm11,%xmm4
mulps  %xmm2,%xmm3
subps  %xmm14,%xmm3
movaps %xmm1,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
movss  %xmm8,%xmm4
xorps  %xmm10,%xmm4
shufps $0x91,%xmm13,%xmm13
shufps $0x12,%xmm4,%xmm9
shufps $0x48,%xmm4,%xmm9
mulps  %xmm13,%xmm9
mulps  %xmm6,%xmm0
addps  %xmm9,%xmm0
movaps %xmm0,%xmm4
unpckhpd %xmm0,%xmm4
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
mulss  %xmm11,%xmm7
mulss  %xmm8,%xmm1
addss  %xmm7,%xmm1
divss  %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm4
divps  %xmm4,%xmm3
movaps %xmm3,(%rsp)
divps  %xmm4,%xmm0
movaps %xmm0,0x10(%rsp)
movss  %xmm1,0x20(%rsp)
mov    %rsp,%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
mov    %rbx,%rax
add    $0x30,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define float* @i33(float* noalias returned %0, float* noalias nocapture %1) {
%3 = alloca [3 x [3 x float]]
%4 = getelementptr inbounds float, float* %1, i64 4
%5 = load float, float* %4
%6 = getelementptr inbounds float, float* %1, i64 5
%7 = bitcast float* %6 to <4 x float>*
%8 = load <4 x float>, <4 x float>* %7
%9 = shufflevector <4 x float> %8, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 0, i32 1>
%10 = bitcast float* %1 to <4 x float>*
%11 = load <4 x float>, <4 x float>* %10
%12 = shufflevector <4 x float> %11, <4 x float> poison, <4 x i32> <i32 0, i32 2, i32 3, i32 1>
%13 = extractelement <4 x float> %11, i64 2
%14 = extractelement <4 x float> %11, i64 3
%15 = shufflevector <4 x float> %8, <4 x float> %11, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
%16 = fneg <4 x float> %15
%17 = extractelement <4 x float> %8, i64 1
%18 = extractelement <4 x float> %16, i64 0
%19 = fmul float %17, %18
%20 = extractelement <4 x float> %8, i64 3
%21 = tail call float @llvm.fmuladd.f32(float %14, float %20, float %19)
%22 = extractelement <4 x float> %16, i64 1
%23 = fmul float %21, %22
%24 = extractelement <4 x float> %8, i64 2
%25 = insertelement <4 x float> poison, float %24, i64 0
%26 = insertelement <4 x float> %25, float %20, i64 1
%27 = insertelement <4 x float> %26, float %5, i64 2
%28 = shufflevector <4 x float> %27, <4 x float> %8, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%29 = fmul <4 x float> %28, %16
%30 = insertelement <4 x float> poison, float %5, i64 0
%31 = shufflevector <4 x float> %30, <4 x float> %11, <4 x i32> <i32 0, i32 6, i32 5, i32 undef>
%32 = shufflevector <4 x float> %31, <4 x float> %8, <4 x i32> <i32 0, i32 1, i32 2, i32 4>
%33 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %32, <4 x float> %9, <4 x float> %29)
%34 = extractelement <4 x float> %33, i64 0
%35 = extractelement <4 x float> %11, i64 0
%36 = tail call float @llvm.fmuladd.f32(float %35, float %34, float %23)
%37 = insertelement <2 x float> poison, float %5, i64 0
%38 = insertelement <2 x float> %37, float %35, i64 1
%39 = fneg <2 x float> %38
%40 = shufflevector <2 x float> %39, <2 x float> poison, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%41 = shufflevector <4 x float> %8, <4 x float> undef, <4 x i32> <i32 1, i32 0, i32 1, i32 2>
%42 = shufflevector <4 x float> %16, <4 x float> %40, <4 x i32> <i32 2, i32 5, i32 undef, i32 undef>
%43 = shufflevector <2 x float> %39, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%44 = shufflevector <4 x float> %42, <4 x float> %43, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%45 = fmul <4 x float> %41, %44
%46 = shufflevector <4 x float> %11, <4 x float> %8, <4 x i32> <i32 7, i32 3, i32 6, i32 5>
%47 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %12, <4 x float> %46, <4 x float> %45)
%48 = extractelement <4 x float> %47, i64 2
%49 = tail call float @llvm.fmuladd.f32(float %13, float %48, float %36)
%50 = bitcast [3 x [3 x float]]* %3 to i8*
%51 = insertelement <4 x float> poison, float %49, i64 0
%52 = shufflevector <4 x float> %51, <4 x float> poison, <4 x i32> zeroinitializer
%53 = fdiv <4 x float> %33, %52
%54 = bitcast [3 x [3 x float]]* %3 to <4 x float>*
store <4 x float> %53, <4 x float>* %54
%55 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %3, i64 0, i64 1, i64 1
%56 = fdiv <4 x float> %47, %52
%57 = bitcast float* %55 to <4 x float>*
store <4 x float> %56, <4 x float>* %57
%58 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %3, i64 0, i64 2, i64 2
%59 = fmul float %14, %22
%60 = tail call float @llvm.fmuladd.f32(float %35, float %5, float %59)
%61 = fdiv float %60, %49
store float %61, float* %58
%62 = bitcast [3 x [3 x float]]* %3 to float**
%63 = call i32 @memcpy(float* %0, float** %62, i32 36)
ret float* %0
}