void MultMatrix(float m0[4][4], float m1[4][4], float dest[4][4]) {
  int i;
  for (i = 0; i < 4; i++) {
    dest[0][i] = m0[0][i] * m1[0][0] + m0[1][i] * m1[0][1] +
                 m0[2][i] * m1[0][2] + m0[3][i] * m1[0][3];
    dest[1][i] = m0[0][i] * m1[1][0] + m0[1][i] * m1[1][1] +
                 m0[2][i] * m1[1][2] + m0[3][i] * m1[1][3];
    dest[2][i] = m0[0][i] * m1[2][0] + m0[1][i] * m1[2][1] +
                 m0[2][i] * m1[2][2] + m0[3][i] * m1[2][3];
    dest[3][i] = m0[3][i] * m1[3][3] + m0[2][i] * m1[3][2] +
                 m0[1][i] * m1[3][1] + m0[0][i] * m1[3][0];
  }
}


x86 assembly (clang, -O0):
<MultMatrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jge    1331 <MultMatrix+0x231>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x10(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x20(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x30(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x10(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x20(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x30(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,0x10(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x10(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x20(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x30(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,0x20(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x30(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x20(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  0x10(%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,0x30(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1117 <MultMatrix+0x17>
pop    %rbp
ret

x86 assembly (clang, -O2):
<MultMatrix>:
mov    $0xfffffffffffffffc,%rax
nopw   0x0(%rax,%rax,1)
movss  0x10(%rdi,%rax,4),%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
mulss  0x4(%rsi),%xmm1
mulss  (%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
mulss  0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x40(%rdi,%rax,4),%xmm0
mulss  0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rdx,%rax,4)
movss  0x10(%rdi,%rax,4),%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
mulss  0x14(%rsi),%xmm1
mulss  0x10(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
mulss  0x18(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x40(%rdi,%rax,4),%xmm0
mulss  0x1c(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rdx,%rax,4)
movss  0x10(%rdi,%rax,4),%xmm0
movss  0x20(%rdi,%rax,4),%xmm1
mulss  0x24(%rsi),%xmm1
mulss  0x20(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
mulss  0x28(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  0x40(%rdi,%rax,4),%xmm0
mulss  0x2c(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x30(%rdx,%rax,4)
movss  0x40(%rdi,%rax,4),%xmm0
movss  0x30(%rdi,%rax,4),%xmm1
mulss  0x38(%rsi),%xmm1
mulss  0x3c(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  0x10(%rdi,%rax,4),%xmm1
movss  0x20(%rdi,%rax,4),%xmm2
mulss  0x34(%rsi),%xmm2
mulss  0x30(%rsi),%xmm1
addss  %xmm0,%xmm2
addss  %xmm2,%xmm1
movss  %xmm1,0x40(%rdx,%rax,4)
inc    %rax
jne    1110 <MultMatrix+0x10>
ret

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

LLVM IR (-O2):
define void @MultMatrix([4 x float]* nocapture %0, [4 x float]* nocapture %1, [4 x float]* nocapture writeonly %2) {
%4 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 0
%5 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 1
%6 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 2
%7 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 0, i64 3
%8 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 0
%9 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 1
%10 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 2
%11 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 1, i64 3
%12 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 0
%13 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 1
%14 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 2
%15 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 2, i64 3
%16 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 3
%17 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 2
%18 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 1
%19 = getelementptr inbounds [4 x float], [4 x float]* %1, i64 3, i64 0
br label %20
20: ; preds = %3, %20
%21 = phi i64 [ 0, %3 ], [ %78, %20 ]
%22 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 %21
%23 = load float, float* %22
%24 = load float, float* %4
%25 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 %21
%26 = load float, float* %25
%27 = load float, float* %5
%28 = fmul float %26, %27
%29 = tail call float @llvm.fmuladd.f32(float %23, float %24, float %28)
%30 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 %21
%31 = load float, float* %30
%32 = load float, float* %6
%33 = tail call float @llvm.fmuladd.f32(float %31, float %32, float %29)
%34 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 %21
%35 = load float, float* %34
%36 = load float, float* %7
%37 = tail call float @llvm.fmuladd.f32(float %35, float %36, float %33)
%38 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 0, i64 %21
store float %37, float* %38
%39 = load float, float* %22
%40 = load float, float* %8
%41 = load float, float* %25
%42 = load float, float* %9
%43 = fmul float %41, %42
%44 = tail call float @llvm.fmuladd.f32(float %39, float %40, float %43)
%45 = load float, float* %30
%46 = load float, float* %10
%47 = tail call float @llvm.fmuladd.f32(float %45, float %46, float %44)
%48 = load float, float* %34
%49 = load float, float* %11
%50 = tail call float @llvm.fmuladd.f32(float %48, float %49, float %47)
%51 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 1, i64 %21
store float %50, float* %51
%52 = load float, float* %22
%53 = load float, float* %12
%54 = load float, float* %25
%55 = load float, float* %13
%56 = fmul float %54, %55
%57 = tail call float @llvm.fmuladd.f32(float %52, float %53, float %56)
%58 = load float, float* %30
%59 = load float, float* %14
%60 = tail call float @llvm.fmuladd.f32(float %58, float %59, float %57)
%61 = load float, float* %34
%62 = load float, float* %15
%63 = tail call float @llvm.fmuladd.f32(float %61, float %62, float %60)
%64 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 2, i64 %21
store float %63, float* %64
%65 = load float, float* %34
%66 = load float, float* %16
%67 = load float, float* %30
%68 = load float, float* %17
%69 = fmul float %67, %68
%70 = tail call float @llvm.fmuladd.f32(float %65, float %66, float %69)
%71 = load float, float* %25
%72 = load float, float* %18
%73 = tail call float @llvm.fmuladd.f32(float %71, float %72, float %70)
%74 = load float, float* %22
%75 = load float, float* %19
%76 = tail call float @llvm.fmuladd.f32(float %74, float %75, float %73)
%77 = getelementptr inbounds [4 x float], [4 x float]* %2, i64 3, i64 %21
store float %76, float* %77
%78 = add nuw nsw i64 %21, 1
%79 = icmp eq i64 %78, 4
br i1 %79, label %80, label %20
80: ; preds = %20
ret void
}