#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*/ GLfloat;

/* Variables and functions */
int /*<<< orphan*/ glMultMatrixf(int /*<<< orphan*/ const *);
void myShadowMatrix(float ground[4], float light[4]) {
  float dot;
  float shadowMat[4][4];
  dot = ground[0] * light[0] + ground[1] * light[1] + ground[2] * light[2] +
        ground[3] * light[3];
  shadowMat[0][0] = dot - light[0] * ground[0];
  shadowMat[1][0] = 0.0 - light[0] * ground[1];
  shadowMat[2][0] = 0.0 - light[0] * ground[2];
  shadowMat[3][0] = 0.0 - light[0] * ground[3];
  shadowMat[0][1] = 0.0 - light[1] * ground[0];
  shadowMat[1][1] = dot - light[1] * ground[1];
  shadowMat[2][1] = 0.0 - light[1] * ground[2];
  shadowMat[3][1] = 0.0 - light[1] * ground[3];
  shadowMat[0][2] = 0.0 - light[2] * ground[0];
  shadowMat[1][2] = 0.0 - light[2] * ground[1];
  shadowMat[2][2] = dot - light[2] * ground[2];
  shadowMat[3][2] = 0.0 - light[2] * ground[3];
  shadowMat[0][3] = 0.0 - light[3] * ground[0];
  shadowMat[1][3] = 0.0 - light[3] * ground[1];
  shadowMat[2][3] = 0.0 - light[3] * ground[2];
  shadowMat[3][3] = dot - light[3] * ground[3];
  glMultMatrixf((const GLfloat *)shadowMat);
}


x86 assembly (clang, -O0):
<myShadowMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x14(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
lea    -0x60(%rbp),%rdi
call   1030 <glMultMatrixf@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<myShadowMatrix>:
sub    $0x48,%rsp
movsd  (%rdi),%xmm2
movsd  (%rsi),%xmm9
movaps %xmm2,%xmm8
movaps %xmm2,%xmm10
movaps %xmm9,%xmm4
shufps $0x1,%xmm2,%xmm4
shufps $0x48,%xmm2,%xmm4
shufps $0x55,%xmm2,%xmm2
movsd  0x8(%rsi),%xmm5
movaps %xmm9,%xmm6
shufps $0x55,%xmm9,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm9,%xmm8
movaps %xmm8,%xmm0
addss  %xmm6,%xmm0
movss  0x8(%rdi),%xmm1
movaps %xmm1,%xmm12
mulss  %xmm5,%xmm12
addss  %xmm12,%xmm0
movss  0xc(%rdi),%xmm3
movaps %xmm5,%xmm11
shufps $0x55,%xmm5,%xmm11
mulss  %xmm3,%xmm11
addss  %xmm11,%xmm0
movaps %xmm0,%xmm7
subss  %xmm8,%xmm7
movss  %xmm7,(%rsp)
movaps %xmm0,%xmm7
subss  %xmm6,%xmm7
movss  %xmm7,0x14(%rsp)
movaps %xmm0,%xmm6
subss  %xmm12,%xmm6
movss  %xmm6,0x28(%rsp)
movlhps %xmm5,%xmm10
movaps %xmm9,%xmm6
shufps $0xd4,%xmm5,%xmm6
shufps $0x28,%xmm6,%xmm10
mulps  %xmm10,%xmm4
xorps  %xmm6,%xmm6
xorps  %xmm7,%xmm7
subps  %xmm4,%xmm7
movups %xmm7,0x4(%rsp)
movlhps %xmm9,%xmm2
movaps %xmm5,%xmm4
shufps $0x4,%xmm1,%xmm4
mulps  %xmm2,%xmm4
xorps  %xmm2,%xmm2
subps  %xmm4,%xmm2
movups %xmm2,0x18(%rsp)
movlhps %xmm9,%xmm1
shufps $0xd4,%xmm5,%xmm3
shufps $0xd4,%xmm9,%xmm5
shufps $0x28,%xmm5,%xmm1
shufps $0x2,%xmm3,%xmm3
mulps  %xmm1,%xmm3
subps  %xmm3,%xmm6
movups %xmm6,0x2c(%rsp)
subss  %xmm11,%xmm0
movss  %xmm0,0x3c(%rsp)
mov    %rsp,%rdi
call   1030 <glMultMatrixf@plt>
add    $0x48,%rsp
ret

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

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